pinstripe 0.14.0 → 0.16.0

package/babel.config.cjs

@@ -0,0 +1,18 @@
+module.exports = {
+  presets: [
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+            node: 'current',
+        },
+      },
+    ],
+  ],
+  env: {
+    test: {
+      plugins: ["@babel/plugin-transform-modules-commonjs"]
+    }
+  }
+};
+  

package/cli.js

@@ -1,13 +1,14 @@
-#!/usr/bin/env node --unhandled-rejections=strict
+#!/usr/bin/env node
 
 import { spawn } from 'child_process';
 
-import { project } from './lib/project.js';
+import { Project } from './lib/project.js';
 import { Command } from './lib/command.js';
-import { createEnvironment } from './lib/environment.js';
+import { importAll } from './lib/import_all.js';
+import { Workspace } from './lib/workspace.js';
 
 (async () => {
-    const { entryPath, localPinstripePath, exists } = await project;
+    const { entryPath, localPinstripePath, exists } = await Project.instance;
     const { argv, env, execPath } = process;
     const args = argv.slice(2);
 
@@ -21,13 +22,13 @@ import { createEnvironment } from './lib/environment.js';
             import(entryPath);
         }
 
-        const { runCommand, resetEnvironment } = await createEnvironment();
+        await importAll();
 
         if(exists){
             Command.unregister('generate-project');
         } else {
-            const allowedCommands = ['generate-project', 'list-commands']
-            Object.keys(Command.classes).forEach(commandName => {
+            const allowedCommands = ['generate-project', 'list-commands'];
+            Command.names.forEach(commandName => {
                 if(!allowedCommands.includes(commandName)){
                     Command.unregister(commandName);
                 }
@@ -35,10 +36,11 @@ import { createEnvironment } from './lib/environment.js';
         }
         
         try {
-            await runCommand(...args);
+            await Workspace.run(async function(){
+                await this.runCommand(...args);
+            });
         } catch(e) {
             console.error(e);
         }
-        await resetEnvironment();
     }
 })();

package/jest.config.cjs

@@ -0,0 +1,6 @@
+// jest.config.js
+module.exports = {
+    "transform": {
+      "^.+\\.[t|j]sx?$": "babel-jest"
+    },
+};

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

@@ -1,49 +1,21 @@
+import { fileURLToPath } from 'url';
 
-import { promisify } from 'util';
-import { readFile } from 'fs';
-import { Volume as MemFs } from 'memfs';
-import * as fs from 'fs';
-import { Union as UnionFs } from 'unionfs';
+import { Class } from "./class.js";
+import { Singleton } from "./singleton.js";
 
-import { Base } from './base.js';
-import { overload } from './overload.js';
 
-export const client = Base.extend().include({
-    initialize(){
-        this.files = {};
+export const Client = Class.extend().include({
+    meta(){
+        this.include(Singleton);
     },
 
-    addFile: overload({
-        ['string, function'](filePath, fn){
-            this.files[filePath] = fn;
-        },
+    initialize(){
+        this.modules = [];
 
-        string(filePath){
-            this.addFile(filePath, async () => {
-                return (await promisify(readFile)(filePath)).toString();
-            });
-        },
-    }),
+        this.addModule(`import ${JSON.stringify(fileURLToPath(`${import.meta.url}/../index.js`))};`);
+    },
 
-    async createFs(entryFilePath){
-        const files = {};
-        const filePaths = Object.keys(this.files);
-        while(filePaths.length){
-            const filePath = filePaths.pop();
-            const data = await this.files[filePath]();
-            files[filePath] = data.replace(/(.*)\/\/\s*pinstripe-if-client:\s*(.*)/g, '$2 // pinstripe-if-server: $1');
-        }
-        return new UnionFs().use(fs).use(new MemFs.fromJSON({
-            ...files,
-            [entryFilePath]: `
-                ${
-                    Object.keys(this.files).filter(filePath => filePath.match(/\/[^\.\/]+(\.client\.js)$/)).map(filePath => `
-                        import ${JSON.stringify(filePath)};
-                    `).join('\n')
-                }
-            `
-        }));
+    addModule(...modules){
+        this.modules.push(...modules);
     }
-}).new();
-
-export const addFileToClient = (...args) => client.addFile(...args);
+});

package/lib/command.js

@@ -1,69 +1,39 @@
 
-import { Base } from './base.js';
-import { Registrable } from './registrable.js';
-import { dasherize } from './inflector.js';
-import { overload } from './overload.js';
-import { thatify } from './thatify.js';
-import { addFileToClient } from './client.js';
+import { Class } from './class.js';
+import { Registry } from './registry.js';
+import { ServiceConsumer } from './service_consumer.js';
+import { inflector } from "./inflector.js";
 
-export const Command = Base.extend().include({
+export const Command = Class.extend().include({
     meta(){
-        this.include(Registrable);
-
-        const { register } = this;
+        this.include(Registry);
+        this.include(ServiceConsumer);
 
         this.assignProps({
-            register(name){
-                return register.call(this, dasherize(name));
+            normalizeName: (...args) => inflector.dasherize(...args),
+
+            get schedules(){
+                if(!this.hasOwnProperty('_schedules')){
+                    this._schedules = [];
+                }
+                return this._schedules;
+            },
+
+            schedule(...args){
+                this.schedules.push(args);
+                return this;
             },
 
-            run(name = 'list-commands', ...args){
-                return this.create(name, ...args).run();
-            }
+            async run(context, name = 'list-commands', ...args){
+                return context.fork().run(async context => {
+                    context.args = [ ...args ];
+                    await this.create(name, context).run();
+                });
+            },
         });
     },
 
-    initialize(environment){
-        this.environment = environment;
-    },
-    
     run(){
         console.error(`No such command "${this.constructor.name}" exists.`);
-    },
-
-    __getMissing(name){
-        return this.environment[name];
     }
 });
-
-
-export const defineCommand = overload({
-    ['string, object'](name, include){
-        const abstract = include.abstract;
-        delete include.abstract;
-        Command.register(name, abstract).include(include);
-    },
-
-    ['string, function'](name, fn){
-        defineCommand(name, { run: thatify(fn) });
-    }
-});
-
-export const commandImporter = dirPath => {
-    return async filePath => {
-        const relativeFilePath = filePath.substr(dirPath.length).replace(/^\//, '');
-
-        if(filePath.match(/\.js$/)){
-            const relativeFilePathWithoutExtension = relativeFilePath.replace(/\.[^/]+$/, '');
-            if(relativeFilePathWithoutExtension == '_importer'){
-                return;
-            }
-            addFileToClient(filePath);
-            const definition = await ( await import(filePath) ).default;
-            if(definition !== undefined){
-                defineCommand(relativeFilePathWithoutExtension, definition);
-            }
-            return;
-        }
-    };
-};

package/lib/commands/_file_importer.js

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

package/lib/commands/drop_database.js

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

package/lib/commands/generate_command.js

@@ -1,32 +1,39 @@
 
-export default async ({
-    cliUtils: { extractArg },
-    fsBuilder: { inProjectRootDir, generateFile, line, indent },
-    snakeify, dasherize
-}) => {
-    const name = snakeify(extractArg(''));
-    if(name == ''){
-        console.error('A command name must be given.');
-        process.exit();
-    }
-
-    await inProjectRootDir(async () => {
 
-        await generateFile(`lib/commands/_importer.js`, { skipIfExists: true }, () => {
-            line();
-            line(`export { commandImporter as default } from 'pinstripe';`);
-            line();
-        });
+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();
+        }
 
-        await generateFile(`lib/commands/${name}.js`, () => {
-            line();
-            line(`export default () => {`);
-            indent(() => {
-                line(`console.log('${dasherize(name)} command coming soon!')`);
+        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();
             });
-            line('};');
-            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_migration.js

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

package/lib/commands/generate_model.js

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

package/lib/commands/generate_node_wrapper.js

@@ -1,36 +1,37 @@
 
-export default async ({
-    cliUtils: { extractArg },
-    fsBuilder: { inProjectRootDir, generateFile, line, indent },
-    snakeify
-}) => {
-    const name = snakeify(extractArg(''));
-    if(name == ''){
-        console.error('A node wrapper name must be given.');
-        process.exit();
-    }
-
-    await inProjectRootDir(async () => {
-
-        await generateFile(`lib/node_wrappers/_importer.js`, { skipIfExists: true }, () => {
-            line();
-            line(`export { nodeWrapperImporter as default } from 'pinstripe';`);
-            line();
-        });
-
-        await generateFile(`lib/node_wrappers/${name}.client.js`, () => {
-            line();
-            line(`export default {`);
-            indent(() => {
-                line(`initialize(){`);
-                    indent(() => {
-                        line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
-                    });
-                line(`}`);
+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/node_wrappers/_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { componentImporter as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/node_wrappers/${normalizedName}.client.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line(`initialize(){`);
+                        indent(() => {
+                            line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
+                        });
+                    line(`}`);
+                });
+                line('};');
+                line();
             });
-            line('};');
-            line();
+    
         });
-
-    });
-};
+    }
+}