pinstripe 0.22.0 → 0.23.0

package/README.md

@@ -0,0 +1,10 @@
+
+# Welcome to Pinstripe
+
+## What is Pinstripe?
+
+A slick web framework for Node.js.
+
+## License
+
+Pinstripe is released under the [MIT License](https://opensource.org/licenses/MIT).

package/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+
+import { Project } from './lib/project.js';
+import { Command } from './lib/command.js';
+import { importAll } from './lib/import_all.js';
+import { Workspace } from './lib/workspace.js';
+
+(async () => {
+    const { entryPath, localPinstripePath, exists } = await Project.instance;
+    const { argv, env, execPath } = process;
+    const args = argv.slice(2);
+
+    if (env.IS_LOCAL_PINSTRIPE != 'true' && localPinstripePath) {
+        spawn(execPath, [localPinstripePath, ...args], {
+            env: { ...env, IS_LOCAL_PINSTRIPE: 'true' },
+            stdio: 'inherit'
+        });
+    } else {
+        if(entryPath){
+            import(entryPath);
+        }
+
+        await importAll();
+
+        if(exists){
+            Command.unregister('generate-project');
+        } else {
+            const allowedCommands = ['generate-project', 'list-commands'];
+            Command.names.forEach(commandName => {
+                if(!allowedCommands.includes(commandName)){
+                    Command.unregister(commandName);
+                }
+            });
+        }
+        
+        try {
+            await Workspace.run(async function(){
+                await this.runCommand(...args);
+            });
+        } catch(e) {
+            console.error(e);
+        }
+    }
+})();

package/lib/class.js

@@ -0,0 +1,64 @@
+
+export class Class {
+
+    static extend(){
+        return class extends this {};
+    }
+
+    static include(...includes){
+        includes.forEach(include => {
+            if(typeof include.meta == 'function') include.meta.call(this);
+            this.prototype.assignProps(include, name => name != 'meta');
+        });
+        return this;
+    }
+
+    static assignProps(...sources){
+        return assignProps(this, ...sources);
+    }
+
+    static new(...args){
+        return new this(...args);
+    }
+
+    static get parent(){
+        return this.__proto__;
+    }
+
+    constructor(...args){
+        let out = this.initialize(...args);
+        if(typeof out?.then == 'function'){
+            return out.then(out => out || this);
+        }
+        return out || this;
+    }
+
+    initialize(){
+
+    }
+
+    assignProps(...sources){
+        return assignProps(this, ...sources);
+    }
+}
+
+const assignProps = (target, ...sources) => {
+    const fn = typeof sources[sources.length - 1] == 'function' ?  sources.pop() :  () => true;
+
+    sources.forEach(source => {
+        Object.getOwnPropertyNames(source).forEach(name => {
+            if(!fn(name)){
+                return;
+            }
+            const descriptor = { ...Object.getOwnPropertyDescriptor(source, name) };
+            const { get: targetGet, set: targetSet } = (Object.getOwnPropertyDescriptor(target, name) || {});
+            const { get = targetGet, set = targetSet } = descriptor;
+            
+            if(get) descriptor.get = get;
+            if(set) descriptor.set = set;
+
+            Object.defineProperty(target, name, descriptor);
+        });
+    });
+    return target;
+};

package/lib/client.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from 'url';
+
+import { Class } from './class.js';
+import { Singleton } from './singleton.js';
+
+export const Client = Class.extend().include({
+    meta(){
+        this.include(Singleton);
+    },
+
+    initialize(){
+        this.modules = [];
+
+        this.addModule(`import ${JSON.stringify(fileURLToPath(`${import.meta.url}/../index.js`))};`);
+    },
+
+    addModule(...modules){
+        this.modules.push(...modules);
+    }
+});

package/lib/command.js

@@ -0,0 +1,39 @@
+
+import { Class } from './class.js';
+import { inflector } from './inflector.js';
+import { Registry } from './registry.js';
+import { ServiceConsumer } from './service_consumer.js';
+
+export const Command = Class.extend().include({
+    meta(){
+        this.include(Registry);
+        this.include(ServiceConsumer);
+
+        this.assignProps({
+            normalizeName: (...args) => inflector.dasherize(...args),
+
+            get schedules(){
+                if(!this.hasOwnProperty('_schedules')){
+                    this._schedules = [];
+                }
+                return this._schedules;
+            },
+
+            schedule(...args){
+                this.schedules.push(args);
+                return this;
+            },
+
+            async run(context, name = 'list-commands', ...args){
+                return context.fork().run(async context => {
+                    context.args = [ ...args ];
+                    await this.create(name, context).run();
+                });
+            },
+        });
+    },
+
+    run(){
+        console.error(`No such command "${this.constructor.name}" exists.`);
+    }
+});

package/lib/commands/_file_importer.js

@@ -0,0 +1 @@
+export { Command as default } from 'pinstripe';

package/lib/commands/drop_database.js

@@ -0,0 +1,6 @@
+
+export default {
+    async run(){
+        await this.database.drop()
+    }
+};

package/lib/commands/generate_command.js

@@ -0,0 +1,39 @@
+
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        const normalizedName = this.inflector.snakeify(name);
+        if(normalizedName == ''){
+            console.error('A command name must be given.');
+            process.exit();
+        }
+
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/commands/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { Command as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/commands/${normalizedName}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line('run(){');
+                    indent(() => {
+                        line(`console.log('${this.inflector.dasherize(normalizedName)} command coming soon!')`);
+                    });
+                    line('}');
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+}
+

package/lib/commands/generate_component.js

@@ -0,0 +1,37 @@
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        const normalizedName = this.inflector.snakeify(name);
+        if(normalizedName == ''){
+            console.error('A node wrapper name must be given.');
+            process.exit();
+        }
+    
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/components/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { Component as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/components/${normalizedName}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line(`initialize(){`);
+                        indent(() => {
+                            line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
+                        });
+                    line(`}`);
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+}

package/lib/commands/generate_migration.js

@@ -0,0 +1,55 @@
+
+export default {
+    async run(){
+        const { extractArg, extractFields, extractOptions } = this.cliUtils;
+
+        const suffix = this.inflector.snakeify(extractArg('migration'));
+        const fields = extractFields();
+        const { table } = extractOptions({
+            table: (() => {
+                const matches = suffix.match(/_to_(.+)$/);
+                if(matches){
+                    return matches[1];
+                }
+            })()
+        });
+
+        const unixTime = Math.floor(new Date().getTime() / 1000);
+        const name = `${unixTime}_${suffix}`;
+
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/migrations/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { Migration as default } from 'pinstripe/database';`);
+                line();
+            });
+    
+            await generateFile(`lib/migrations/${name}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line(`async migrate(){`);
+                    indent(() => {
+                        if(table && fields.length){
+                            line(`await this.database.table('${table}', async ${table} => {`);
+                            indent(() => {
+                                fields.forEach(({ name, type }) => {
+                                    line(`await ${table}.addColumn('${name}', '${type}');`);
+                                });
+                            })
+                            line(`});`);
+                        } else {
+                            line();
+                        }
+                    })
+                    line(`}`);
+                })
+                line('};');
+                line();
+            });
+        });
+    }
+}

package/lib/commands/generate_model.js

@@ -0,0 +1,43 @@
+
+export default {
+    async run(){
+
+        const { extractArg, extractFields } = this.cliUtils;
+        const name = this.inflector.snakeify(extractArg(''));
+        if(name == ''){
+            console.error('A model name must be given.');
+            process.exit();
+        }
+        const fields = extractFields();
+    
+        const collectionName = this.inflector.camelize(this.inflector.pluralize(name));
+        if(!await this.database[collectionName]){
+            const denormalizedFields = fields.map(({ mandatory, name, type }) => {
+                return `${ mandatory ? '^' : '' }${name}:${type}`
+            });
+            await this.runCommand('generate-migration', `create_${name}`, ...denormalizedFields, '--table', collectionName)
+        }
+    
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/models/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { Row as default } from 'pinstripe/database';`);
+                line();
+            });
+    
+            await generateFile(`lib/models/${name}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line();
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+}

package/lib/commands/generate_project.js

@@ -0,0 +1,133 @@
+
+import { spawnSync } from 'child_process';
+import * as crypto from 'crypto';
+
+export default {
+   async run(){
+
+      const { extractArg, extractOptions } = this.cliUtils;
+      const name = extractArg('');
+      if(name == ''){
+         console.error('A project name must be given.');
+         process.exit();
+      }
+      const { with: dependencies } = extractOptions({
+         with: []
+      });
+      if(!dependencies.includes('pinstripe')){
+         dependencies.unshift('pinstripe')
+      }
+   
+      const { generateDir, generateFile, line, indent, echo } = this.fsBuilder;
+   
+      await generateDir(name, async () => {
+   
+         await generateFile(`package.json`, () => {
+            echo(JSON.stringify({
+               type: "module",
+               name,
+               version: "0.0.0",
+               license: "MIT",
+               exports: {
+                  ".": "./lib/index.js"
+               },
+            }, null, 2));
+         });
+
+         await generateFile(`pinstripe.config.js`, () => {
+            line();
+            line(`const environment = process.env.NODE_ENV || 'development';`);
+            line();
+            line(`let database;`);
+            line(`if(environment == 'production'){`)
+            indent(() => {
+               line(`database = {`);
+               indent(() => {
+                  line(`adapter: 'mysql',`)
+                  line(`host: 'localhost',`);
+                  line(`user: 'root',`);
+                  line(`password: '',`);
+                  line(`database: \`${this.inflector.snakeify(name)}_\${environment}\``);
+               });
+               line(`};`);
+            });
+            line(`} else {`);
+            indent(() => {
+               line(`database = {`);
+               indent(() => {
+                  line(`adapter: 'sqlite',`);
+                  line(`filename: \`\${environment}.db\``)
+               });
+               line(`};`);
+            });
+            line(`}`);
+            line();
+            line(`let mail;`);
+            line(`if(environment == 'production'){`)
+            indent(() => {
+               line(`mail = {`);
+               indent(() => {
+                  line(`adapter: 'smtp',`)
+                  line(`host: "smtp.example.com",`)
+                  line(`port: 465,`);
+                  line(`secure: true, // use TLS`);
+                  line(`auth: {`);
+                  indent(() => {
+                     line(`user: "username",`);
+                     line(`pass: "password",`);
+                  });
+                  line(`}`);
+               });
+               line(`};`);
+            });
+            line(`} else {`);
+            indent(() => {
+               line(`mail = {`);
+               indent(() => {
+                  line(`adapter: 'dummy'`);
+               });
+               line(`};`);
+            });
+            line(`}`);
+            line();
+            line(`export default {`);
+            indent(() => {
+               line(`database,`);
+               line(`mail,`);
+               line(`salt: '${crypto.randomUUID()}'`)
+            })
+            line(`};`);
+         });
+   
+         await generateFile(`lib/index.js`, () => {
+            line();
+            line(`import { importAll } from 'pinstripe';`);
+            dependencies.forEach((dependency) => {
+               if(dependency != 'pinstripe') line(`import '${dependency}';`);
+            });
+            line();
+            line(`importAll(import.meta.url);`);
+            line();
+         });
+   
+         await generateFile(`README.md`, () => {
+            line();
+            line(`# ${name}`);
+            line();
+            line('## Getting started');
+            line();
+            line('```bash');
+            indent(() => {
+               line('pinstripe init-database');
+               line('pinstripe start-server');
+            });
+            line('```');
+            line();
+         });
+   
+         spawnSync('yarn', [ 'add', ...dependencies ], {
+            stdio: 'inherit'
+         });
+      });
+   }
+};

package/lib/commands/generate_service.js

@@ -0,0 +1,32 @@
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        if(name == ''){
+            console.error('A service name must be given.');
+            process.exit();
+        }
+    
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/services/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { ServiceFactory as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/services/${this.inflector.snakeify(name)}.js`, () => {
+                line();
+                line(`export default () => {`);
+                indent(() => {
+                    line(`return 'Example ${this.inflector.camelize(name)} service'`);
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+};

package/lib/commands/generate_static_site.js

@@ -0,0 +1,74 @@
+
+import { default as mimeTypes } from 'mime-types';
+
+export default {
+    async run(){
+        this.pages = {};
+        const urls = this.viewNames.filter(path => !path.match(/(^|\/)_/)).map(path => {
+            return new URL(path, 'http://127.0.0.1/');
+        });
+
+        while(urls.length){
+            await this.crawlPage({ _url: urls.shift() });
+        }
+
+        const pages = Object.values(this.pages).filter(page => page.status == 200 && Object.keys(page.params).length == 1);
+        const { inProjectRootDir, generateDir, generateFile, echo } = this.fsBuilder;
+
+        await inProjectRootDir(async () => {
+            await generateDir('build/static', async () => {
+                while(pages.length){
+                    const { params, headers } = pages.shift();
+                    const contentType = headers['content-type'];
+
+                    const path = params._url.pathname;
+                    let filePath = path.replace(/^\//, '');
+                    if(filePath.match(/(^|\/)$/)){
+                        filePath = `${filePath}index`;
+                    }
+                    if(!filePath.match(/[^/]+\.[^/]+$/)){
+                        filePath = `${filePath}.${mimeTypes.extension(contentType)}`
+                    }
+                    
+                    const data = (await this.fetch({ _url: new URL(path, 'http://127.0.0.1/') }))[2];
+
+                    await generateFile(filePath, () => {
+                        echo(data.join(''));
+                    });
+                }
+            });
+        });
+    },
+
+    async crawlPage(params){
+        const hash = JSON.stringify(params);
+        if(this.pages[hash]) return;
+        const page = { params };
+        this.pages[hash] = page;
+        const [ status, headers, data ] = await this.fetch(params);
+        page.status = status;
+        page.headers = headers;
+        if(status != 200 || headers['content-type'] != 'text/html') return;
+        const html = data.join('');
+        const virtualDom = this.parseHtml(html);
+        const urls = this.extractUrls(virtualDom);
+        while(urls.length){
+            const url = urls.shift();
+            await this.crawlPage({ ...url.params, _url: url });
+        }
+    },
+
+    extractUrls(virtualDom){
+        const out = [];
+        virtualDom.traverse(({ attributes }) => {
+            ['src', 'href'].forEach(name => {
+                const value = attributes[name];
+                if(!value) return;
+                const url = new URL(value, 'http://127.0.0.1/');
+                if(url.host != '127.0.0.1') return;
+                out.push(url);
+            });
+        });
+        return out;
+    }
+};

package/lib/commands/generate_view.js

@@ -0,0 +1,44 @@
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        let normalizedName = name.replace(/^\//, '');
+        if(name == ''){
+            console.error('A view name must be given.');
+            process.exit();
+        }
+    
+        if(!normalizedName.match(/\.[^\/]+$/)){
+            normalizedName = `${normalizedName}.js`;
+        }
+    
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/views/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { View as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/views/${normalizedName}`, () => {
+                line();
+                line('export default {');
+                indent(() => {
+                    line('render(){')
+                    indent(() => {
+                        line('return this.renderHtml`')
+                        indent(() => {
+                            line(`<h1>${normalizedName} view<h1></h1>`);
+                        });
+                        line('`;')
+                    });
+                    line('}')
+                });
+                line('};');
+                line();
+            });
+        });
+    }
+};

package/lib/commands/init_database.js

@@ -0,0 +1,9 @@
+
+import { Command } from 'pinstripe';
+
+export default {
+    async run(){
+        await this.runCommand('migrate-database');
+        await this.runCommand('seed-database');
+    }
+}

package/lib/commands/list_commands.js

@@ -0,0 +1,15 @@
+
+import chalk from 'chalk';
+import { Command } from 'pinstripe';
+
+export default {
+    run(){
+        console.log('');
+        console.log('The following commands are available:');
+        console.log('');
+        Command.names.forEach(commandName => {
+            console.log(`  * ${chalk.green(commandName)}`);
+        });
+        console.log('');
+    }
+};