pinstripe 0.7.0 → 0.11.0

package/README.md

@@ -3,7 +3,7 @@
 
 ## What is Pinstripe?
 
-Pinstripe is a fullstack JavaScript web framework for Node.js and the browser that follows the [model-view-controller (MVC)](https://en.wikipedia.org/wiki/Model-view-controller) design pattern.
+Pinstripe is a fullstack JavaScript web framework for Node.js.
 
 ## License
 

package/cli.js

@@ -4,7 +4,7 @@ import { spawn } from 'child_process';
 
 import { importAll } from './lib/import_all.js';
 import { project } from './lib/project.js';
-import { Command } from './lib/command.server.js';
+import { Command } from './lib/command.js';
 import { Environment } from './lib/environment.js';
 
 (async () => {
@@ -35,7 +35,12 @@ import { Environment } from './lib/environment.js';
             });
         }
 
-        const { runCommand } = Environment.new();
-        await runCommand(...args);
+        const { runCommand, resetEnvironment } = Environment.new();
+        try {
+            await runCommand(...args);
+        } catch(e) {
+            console.error(e);
+        }
+        await resetEnvironment();
     }
 })();

package/lib/async_path_builder.js

@@ -1,53 +1,52 @@
 
 import { Base } from './base.js';
 
-export const AsyncPathBuilder = Base.extend().open(Class => Class
-    .props({
-        initialize(startObject, path = []){
-            this._startObject = startObject;
-            this._path = path;
-        },
+export const AsyncPathBuilder = Base.extend().include({
+    initialize(startObject, path = []){
+        this._startObject = startObject;
+        this._path = path;
+    },
 
-        __getMissing(name){
-            return new this.constructor(this._startObject, [...this._path, [ name ]]);
-        },
+    __getMissing(name){
+        return new this.constructor(this._startObject, [...this._path, name ]);
+    },
 
-        __call(...args){
-            const path = [...this._path];
-            path.push([...path.pop(), ...args]);
-            const name = path[path.length - 1][0];
-        
-            return new this.constructor(this._startObject, path);
-        },
+    __call(...args){
+        return new this.constructor(this._startObject, [...this._path, args ]);
+    },
 
-        then(...args){
-            return unwrap(this._startObject, [...this._path]).then(...args);
-        },
-
-        async log(){
-            try {
-                console.log(
-                    await unwrap(this._startObject, [...this._path])
-                );
-            } catch (e) {
-                console.error(e);
-            }
-        }
-    })
-);
+    then(...args){
+        return unwrap(this._startObject, [...this._path]).then(...args);
+    }
+});
 
-async function unwrap(startObject, path) {
+const unwrap = async (startObject, path) => {
     let out = await startObject;
+    let originalPath = [ ...path ];
     while(path.length){
-        const [ name, ...args ] = path.shift();
-        if(typeof out[name] == 'function'){
-            out = await out[name](...args);
-        } else {
-            out = await out[name];
-            if(typeof out == 'function'){
-                out = await out(...args);
+        if(out == undefined){
+            const completedPath = originalPath.slice(0, originalPath.length - path.length);
+            throw new Error(`Can't unwrap object${formatPath(originalPath)} (object${formatPath(completedPath)} is undefined)`);
+        }
+        if(typeof path[0] == 'string'){
+            const name = path.shift();
+            if(Array.isArray(path[0])){
+                const args = path.shift();
+                if(typeof out[name] != 'function'){
+                    out = await out[name];
+                    path.unshift(args);
+                } else {
+                    out = await out[name](...args);
+                }    
+            } else {
+                out = await out[name];
             }
+        } else {
+            const args = path.shift();
+            out = await out(...args);
         }
     }
     return out;
 };
+
+const formatPath = path => path.map(segment => typeof segment == 'string' ? `.${segment}` : '(...)').join('')

package/lib/async_path_builder.test.js

@@ -0,0 +1,27 @@
+
+import { AsyncPathBuilder } from './async_path_builder.js';
+
+test('AsyncPathBuilder (1)', async () => {
+    const hello = AsyncPathBuilder.new((name = 'world') => `hello ${name}`);
+    
+    expect(hello instanceof AsyncPathBuilder).toBe(true);
+    expect(await hello()).toBe("hello world");
+    expect(await hello().length).toBe(11);
+    expect(await hello('jody')).toBe("hello jody");
+    expect(await hello('jody').length).toBe(10);
+});
+
+test('AsyncPathBuilder (2)', async () => {
+    const foo = AsyncPathBuilder.new({
+        async bar(){
+            return this;
+        },
+
+        async baz(){
+            return "boo";
+        }
+    });
+    
+    expect(await foo.bar().baz()).toBe("boo");
+    expect(await foo.bar().baz().length).toBe(3);
+});

package/lib/base.js

@@ -3,23 +3,17 @@ import { getAllProps } from './get_all_props.js';
 
 export class Base {
 
-    static open(fn){
-        fn.call(this, this);
-        return this;
-    }
-
-    static staticProps(...args){
-        assignProps(this, ...args);
-        return this;
-    }
-
-    static props(...args){
-        assignProps(this.prototype, ...args);
-        return this;
+    static assignProps(...args){
+        return assignProps(this, ...args);
     }
 
     static include(...args){
-        this.open(...args);
+        args.forEach(arg => {
+            if(typeof arg.meta == 'function'){
+                arg.meta.call(this);
+            }
+            this.prototype.assignProps(arg, name => name != 'meta');
+        });
         return this;
     }
 
@@ -30,6 +24,10 @@ export class Base {
     static extend(){
         return class extends this {};
     }
+
+    static get parent(){
+        return this.__proto__;
+    }
     
     constructor(...args){
         let out = this.initialize(...args);
@@ -43,6 +41,10 @@ export class Base {
         
     }
 
+    assignProps(...args){
+        return assignProps(this, ...args);
+    }
+
     get __proxy(){
         let out = this;
 
@@ -51,10 +53,11 @@ export class Base {
         const isGetMissingMethod = typeof this.__getMissing == 'function';
         const isSetMissingMethod = typeof this.__setMissing == 'function';
         const isCallMethod = typeof this.__call == 'function';
+        const isKeysMethod = typeof this.__keys == 'function';
 
         if(isGetMissingMethod || isCallMethod){
             traps.get = (target, name) => {
-                if(getAllProps(this).includes(name)){
+                if(getAllProps(this).includes(name) || name.match(/^_/)){
                     return this[name];
                 }
                 if(isGetMissingMethod && name != 'then'){
@@ -64,7 +67,7 @@ export class Base {
         }
         if(isSetMissingMethod || isCallMethod){
             traps.set = (target, name, value) => {
-                if(getAllProps(this).includes(name)){
+                if(getAllProps(this).includes(name) || name.match(/^_/)){
                     this[name] = value;
                 } else if(isSetMissingMethod){
                     this.__setMissing(name, value);
@@ -74,10 +77,23 @@ export class Base {
         }
         if(isCallMethod){
             out = () => {};
+            out.__proto__ = this;
             traps.apply = (target, thisArg, args) => {
                 return this.__call(...args);
             };
         }
+        if(isKeysMethod){
+            traps.ownKeys = () => {
+                return this.__keys();
+            };
+
+            traps.getOwnPropertyDescriptor = (target, prop) => {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            }
+        }
 
         if(Object.keys(traps).length){
             out = new Proxy(out, traps);
@@ -93,9 +109,27 @@ export class Base {
 };
 
 const assignProps = (target, ...sources) => {
+    const fn = typeof sources[sources.length - 1] == 'function' ?  sources.pop() :  () => true;
+
     sources.forEach(source => {
         Object.getOwnPropertyNames(source).forEach(name => {
-            Object.defineProperty(target, name, Object.getOwnPropertyDescriptor(source, name));
+            if(!fn(name)){
+                return;
+            }
+            const descriptor = { ...Object.getOwnPropertyDescriptor(source, name) };
+            const { get } = descriptor;
+            if(get){
+                descriptor.get = function(...args){
+                    return get.call(this.__proxy || this, ...args);
+                };
+            }
+            const { set } = descriptor;
+            if(set){
+                descriptor.set = function(...args){
+                    set.call(this.__proxy || this, ...args);
+                };
+            }
+            Object.defineProperty(target, name, descriptor);
         });
     });
     return target;

package/lib/base.test.js

@@ -0,0 +1,80 @@
+
+import { Base } from './base.js';
+
+test(`Base - initialize won't call magic methods`, async () => {
+    const fixture = Base.extend().include({
+        initialize(){
+            this.foo = 'bar';
+        },
+
+        __getMissing(name){
+            return 'baz';
+        }
+    }).new();
+
+    expect(fixture.bar).toBe("baz");
+    expect(fixture.foo).toBe("bar");
+});
+
+test('Base - magic methods should callable from getters', async () => {
+    const fixture = Base.extend().include({
+        get foo(){
+            return this.bar;
+        },
+
+        __getMissing(name){
+            return 'baz';
+        }
+    }).new();
+
+    expect(fixture.bar).toBe("baz");
+    expect(fixture.foo).toBe("baz");
+});
+
+test(`Base - properties starting with an underscore won't invoke a magic method`, async () => {
+    const fixture = Base.extend().include({
+        get foo(){
+            if(!this._foo){
+                this._foo = 'bar';
+            }
+            return this._foo;
+        },
+
+        __getMissing(name){
+            return 'baz';
+        },
+
+        __setMissing(name, value){
+            
+        }
+    }).new();
+
+    expect(fixture.bar).toBe("baz");
+    expect(fixture.foo).toBe("bar");
+});
+
+test(`Base - if the __call has been defined getting/setting still works`, async () => {
+    const fixture = Base.extend().include({
+        initialize(){
+            this.foo = "bar";
+        },
+
+        __call(...args){
+            
+        }
+    }).new();
+
+    expect(fixture.foo).toBe("bar");
+});
+
+test(`Base - can produce dynamic keys`, () => {
+    const fixture = Base.extend().include({
+        baz: 'hello world',
+
+        __keys(){
+            return ['foo', 'bar'];
+        }
+    }).new();
+
+    expect(Object.keys(fixture)).toEqual(['foo', 'bar']);
+});

package/lib/client.js

@@ -0,0 +1,49 @@
+
+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 { Base } from './base.js';
+import { overload } from './overload.js';
+
+export const client = Base.extend().include({
+    initialize(){
+        this.files = {};
+    },
+
+    addFile: overload({
+        ['string, function'](filePath, fn){
+            this.files[filePath] = fn;
+        },
+
+        string(filePath){
+            this.addFile(filePath, async () => {
+                return (await promisify(readFile)(filePath)).toString();
+            });
+        },
+    }),
+
+    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')
+                }
+            `
+        }));
+    }
+}).new();
+
+export const addFileToClient = (...args) => client.addFile(...args);

package/lib/command.js

@@ -0,0 +1,69 @@
+
+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';
+
+export const Command = Base.extend().include({
+    meta(){
+        this.include(Registrable);
+
+        const { register } = this;
+
+        this.assignProps({
+            register(name){
+                return register.call(this, dasherize(name));
+            },
+
+            run(name = 'list-commands', ...args){
+                return this.create(name, ...args).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/_importer.js

@@ -1,4 +1,2 @@
 
-import { Command } from 'pinstripe';
-
-export default Command.importer;
+export { commandImporter as default } from 'pinstripe';

package/lib/commands/create_database.js

@@ -0,0 +1,2 @@
+
+export default ({ database }) => database.create();

package/lib/commands/drop_database.js

@@ -0,0 +1,2 @@
+
+export default ({ database }) => database.drop();

package/lib/commands/generate_command.js

@@ -0,0 +1,32 @@
+
+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();
+        });
+
+        await generateFile(`lib/commands/${name}.js`, () => {
+            line();
+            line(`export default () => {`);
+            indent(() => {
+                line(`console.log('${dasherize(name)} command coming soon!')`);
+            });
+            line('};');
+            line();
+        });
+
+    });
+};

package/lib/commands/generate_migration.js

@@ -0,0 +1,45 @@
+
+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];
+            }
+        })()
+    });
+
+    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();
+        });
+
+        await generateFile(`lib/migrations/${name}.js`, () => {
+            line();
+            line(`export default async ({ database }) => {`);
+            indent(() => {
+                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

@@ -0,0 +1,44 @@
+
+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();
+        });
+
+        await generateFile(`lib/models/${name}.js`, () => {
+            line();
+            line(`export default {`);
+            indent(() => {
+                line();
+            });
+            line('};');
+            line();
+        });
+
+    });
+};

package/lib/commands/generate_project.js

@@ -0,0 +1,49 @@
+
+import { spawnSync } from 'child_process';
+
+export default async ({
+   cliUtils: { extractArg, extractOptions },
+   fsBuilder: { generateDir, generateFile, line, indent, echo }
+}) => {
+   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')
+   }
+
+   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(`lib/index.js`, () => {
+         line();
+         line(`import { importAll } from 'pinstripe';`);
+         line();
+         line(`importAll(import.meta.url);`);
+         line();
+      });
+
+      spawnSync('yarn', [ 'add', ...dependencies ], {
+         stdio: 'inherit'
+      });
+
+   });
+};