#!/usr/local/bin/raku

use lib "lib";
use DB::Pg;
use JSON::Pretty;
use Getopt::Long;
use API::Db::App;
use API::Db::Mods;
use API::Db::Roles;
use API::Db::Templates;

# get-options (
#     "app" => our $app,
#     "mods" => our $mods,
#     "roles" => our $roles,
#     "templates" => our $templates,
#     "schema=s" => our $schema
# );

our $pg;


            
sub usage {
    say $*PROGRAM-NAME;
    say q:to/END-USAGE/;
    Reads the meta-data for a given DB schema and generates code that implements a set of REST APIs for the tables in that schema. The application 
    recognizes most db types and foreign keys.

        --app - Generate the Bailador app that implements the REST APIs.
    
        --mods - Generate empty Class modules that can be modified by users (one to implement each role).
    
        --roles - Generate roles implemented by the modules (one for each table in the schema).
    
        --templates - Generate HTML template interface.
    
        --list - List the DB schemas.
    
        --dbname=[db name] - Defaults to value of ENV Var DB_NAME.

        --host=[host name] - Defaults to value of ENV Var DB_HOST.

        --user=[db user name] - Defaults to value of ENV Var DB_USER.

        --pass=[db user password] - Defaults to value of ENV Var DB_PASSWORD.

        --schema=[schema name] - Defaults to 'public'.

        --prefix=[prefix name] - Defaults to the schema name.
    
        --help - Displays this message.
    END-USAGE
    exit;
}

sub list-schemas-and-exit {
    # list the schemas
    say "Schemas : ";
    our $i = 0;
    our %schemas;
    for $pg.query('select schema_name from information_schema.schemata').hashes -> %h {
        
        for %h.kv -> $key, $value {
            say  ++$i ~ ' : ' ~ ($value || '<NULL>');
            %schemas{$i} = $value;
            #say "setting $i to " ~ %schemas<$i>;
        }
    }
    exit;
    #our $schema = 0;
    #while ($i < $schema || $schema < 1) {
        #say "Choose a schema number : ";
        #$schema = Int(get);
        #say "Reading schema : $schema => " ~ %schemas{$schema};
    #}
}

sub check-schema-name ($schema) {
    my $schema-exists = False;
    for $pg.query( 'select schema_name from information_schema.schemata where schema_name=$1', $schema ) -> $result {
        if $result eq $schema {
            $schema-exists = True;
        }
    }
    die "No Such Schema $schema\nUse '--list' to show valid schemas." unless $schema-exists;
}

sub get-tables ($schema) {
    our %tables;
    for $pg.query('select table_name from information_schema.tables where table_type = $1 and table_schema = $2', 
        'BASE TABLE', $schema ).hashes -> %h {
        for %h.kv -> $key, $value {
            for $pg.query('select a.column_name, a.data_type, a.column_default, a.is_nullable, c.table_name as references_table, c.column_name as references_column from information_schema.columns a left join information_schema.key_column_usage b on (b.column_name=a.column_name and b.table_name=a.table_name and b.constraint_name~$1) left join information_schema.constraint_column_usage c on (c.constraint_name=b.constraint_name)where a.table_name=$2 and a.table_schema=$3',
                '_fkey$', $value, $schema).hashes -> %c {
                push %tables{$value}, %c;
            }
        }
    }
    return %tables;
}

sub MAIN( Bool :$app

False


    our $conninfo = join " ",
        ('dbname=' ~ ($dbname || die("missing DB_NAME in environment"))),
        ("host=$host"),
        ("user=$user"),
        ("password=$password");
    $pg = DB::Pg.new(:$conninfo);

    usage()                     if $help;
    list-schemas-and-exit       if $list;
    check-schema-name ($schema) if $schema ne 'public';

    our %tables = get-tables( $schema );
    say to-json %tables;
    unless defined($prefix) { $prefix = $schema.tc }
    
    make_app($dbname, $schema, $prefix, %tables) if $app;
    make_mods($schema, $prefix, %tables) if $mods;

    my $meta-conn = q/my $conninfo = join " ",
        ('dbname=' ~ (%*ENV<DB_NAME> || die("missing DB_NAME in environment"))),
        ("host=$_" with %*ENV<DB_HOST>),
        ("user=$_" with %*ENV<DB_USER>),
        ("password=$_" with %*ENV<DB_PASSWORD>);/;

    make_roles($schema, $prefix, $meta-conn, %tables) if $roles;
    make_templates( $schema, $prefix, %*ENV<APP_HOST>, %*ENV<APP_PORT>, %tables ) if $templates;
}


root

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


mro

Marrow v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation