pinstripe 0.22.0 → 0.24.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/app.js

@@ -0,0 +1,35 @@
+
+import { Class } from './class.js';
+import { Registry } from './registry.js';
+import { View } from './view.js';
+import { ServiceConsumer } from './service_consumer.js';
+
+export const App = Class.extend().include({
+    meta(){
+        this.include(Registry);
+        this.include(ServiceConsumer);
+    },
+
+    compose(){
+        return [];
+    },
+
+    get viewMapper(){
+        if(!this._viewMapper){
+            this._viewMapper = View.mapperFor(this.compose());
+        }
+        return this._viewMapper;
+    },
+
+    renderView(...args){
+        return this.viewMapper.renderView(this.context, ...args);
+    },
+
+    isView(...args){
+        return this.viewMapper.isView(...args);
+    },
+
+    get viewNames(){
+        return this.viewMapper.viewNames;
+    }
+});

package/lib/apps/_file_importer.js

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

package/lib/apps/docs.js

@@ -0,0 +1,6 @@
+
+export default {
+    compose(){
+        return ['shared', 'docs'];
+    }
+};

package/lib/apps/main.js

@@ -0,0 +1,6 @@
+
+export default {
+    compose(){
+        return ['shared', 'main'];
+    }
+};

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,41 @@
+
+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(name){
+                return inflector.dasherize(name);
+            },
+
+            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_app.js

@@ -0,0 +1,41 @@
+
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        const normalizedName = this.inflector.snakeify(name);
+        if(normalizedName == ''){
+            console.error('An app name must be given.');
+            process.exit();
+        }
+
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/apps/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { App as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/apps/${normalizedName}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line('compose(){');
+                    indent(() => {
+                        line(`return ['shared', '${this.inflector.dasherize(normalizedName)}'];`);
+                    });
+                    line('}');
+                });
+                line('};');
+                line();
+            });
+    
+        });
+
+        await this.runCommand('generate-view', `${normalizedName}/index`);
+    }
+}
+

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,51 @@
+
+export default {
+    async run(){
+        const { extractArg } = this.cliUtils;
+        const name = this.inflector.snakeify(extractArg(''));
+        if(name == ''){
+            console.error('A component 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/${name}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line(`initialize(...args){`);
+                        indent(() => {
+                            line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
+                            line();
+                            line('this.shadow.patch(`');
+                            indent(() => {
+                                line(`<style>`);
+                                indent(() => {
+                                    line(`.root {`);
+                                    indent(() => {
+                                        line(`background: yellow;`)
+                                    })
+                                    line(`}`);
+                                });
+                                line(`</style>`);
+                                line(`<div class="root"><slot></div>`);
+                            });
+                            line('`);');
+                        });
+                    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();
+            });
+    
+        });
+    }
+};