pinstripe 0.9.0 → 0.12.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

@@ -2,10 +2,9 @@
 
 import { spawn } from 'child_process';
 
-import { importAll } from './lib/import_all.js';
 import { project } from './lib/project.js';
 import { Command } from './lib/command.js';
-import { Environment } from './lib/environment.js';
+import { createEnvironment } from './lib/environment.js';
 
 (async () => {
     const { entryPath, localPinstripePath, exists } = await project;
@@ -18,12 +17,12 @@ import { Environment } from './lib/environment.js';
             stdio: 'inherit'
         });
     } else {
-        await importAll();
         if(entryPath){
-            await import(entryPath);
-            await importAll();
+            import(entryPath);
         }
 
+        const { runCommand, resetEnvironment } = await createEnvironment();
+
         if(exists){
             Command.unregister('generate-project');
         } else {
@@ -34,8 +33,7 @@ import { Environment } from './lib/environment.js';
                 }
             });
         }
-
-        const { runCommand, resetEnvironment } = Environment.new();
+        
         try {
             await runCommand(...args);
         } catch(e) {

package/lib/async_path_builder.js

@@ -15,6 +15,10 @@ export const AsyncPathBuilder = Base.extend().include({
         return new this.constructor(this._startObject, [...this._path, args ]);
     },
 
+    get toString(){
+        return this.__getMissing('toString');
+    },
+
     then(...args){
         return unwrap(this._startObject, [...this._path]).then(...args);
     }

package/lib/async_path_builder.test.js

@@ -25,3 +25,14 @@ test('AsyncPathBuilder (2)', async () => {
     expect(await foo.bar().baz()).toBe("boo");
     expect(await foo.bar().baz().length).toBe(3);
 });
+
+test('AsyncPathBuilder (3)', async () => {
+    const foo = AsyncPathBuilder.new({
+        toString(){
+            return "hello world";
+        }
+    });
+    
+    expect(await foo.toString()).toBe("hello world");
+});
+

package/lib/base.js

@@ -86,6 +86,13 @@ export class Base {
             traps.ownKeys = () => {
                 return this.__keys();
             };
+
+            traps.getOwnPropertyDescriptor = (target, prop) => {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            }
         }
 
         if(Object.keys(traps).length){
@@ -110,17 +117,21 @@ const assignProps = (target, ...sources) => {
                 return;
             }
             const descriptor = { ...Object.getOwnPropertyDescriptor(source, name) };
-            const { get } = descriptor;
+            const { get, set } = descriptor;
+            const { get: targetGet, set: targetSet } = (Object.getOwnPropertyDescriptor(target, name) || {});
             if(get){
                 descriptor.get = function(...args){
                     return get.call(this.__proxy || this, ...args);
                 };
+            } else if(targetGet) {
+                descriptor.get = targetGet;
             }
-            const { set } = descriptor;
             if(set){
                 descriptor.set = function(...args){
                     set.call(this.__proxy || this, ...args);
                 };
+            } else if(targetSet){
+                descriptor.set = targetSet;
             }
             Object.defineProperty(target, name, descriptor);
         });

package/lib/base.test.js

@@ -65,32 +65,34 @@ test(`Base - if the __call has been defined getting/setting still works`, async
     }).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']);
+});
 
-// test(`Base - classes can be included in other classes`, () => {
-//     const Foo = Base.extend().include({
-//         fruit(){
-//             return 'apple';
-//         }
-//     });
-//     const Bar = Base.extend().include(Foo);
-
-//     expect(Foo.new().fruit()).toBe('apple');
-//     expect(Bar.new().fruit()).toBe('apple');
-// });
-
-// test(`Base - abstract classes can be included in other classes`, () => {
-//     const Foo = Base.extend().include({
-//         abstract: true,
-
-//         fruit(){
-//             return 'apple';
-//         }
-//     });
-//     const Bar = Base.extend().include(Foo);
-//     const Baz = Base.extend().include(Bar);
-
-//     expect(typeof Foo.new().fruit).toBe('undefined');
-//     expect(Bar.new().fruit()).toBe('apple');
-//     expect(Baz.new().fruit()).toBe('apple');
-// });
+test(`Base - getters and setters with same name can be defined independently`, () => {
+    const fixture = Base.extend().include({
+        meta(){
+            this.prototype.assignProps({
+                get foo(){
+                    return 'bar';
+                }
+            });
+        },
+
+        set foo(value){
+            
+        }
+    }).new();
+
+    expect(fixture.foo).toEqual('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

@@ -4,6 +4,7 @@ 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(){
@@ -47,3 +48,22 @@ export const defineCommand = overload({
         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

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

package/lib/commands/create_database.js

@@ -1,4 +1,2 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('create-database', ({ database }) => database.create());
+export default ({ database }) => database.create();

package/lib/commands/drop_database.js

@@ -1,4 +1,2 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('drop-database', ({ database }) => database.drop());
+export default ({ database }) => database.drop();

package/lib/commands/generate_command.js

@@ -1,7 +1,5 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-command', async ({
+export default async ({
     cliUtils: { extractArg },
     fsBuilder: { inProjectRootDir, generateFile, line, indent },
     snakeify, dasherize
@@ -14,17 +12,21 @@ defineCommand('generate-command', async ({
 
     await inProjectRootDir(async () => {
 
-        await generateFile(`lib/commands/${name}.js`, () => {
+        await generateFile(`lib/commands/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { commandImporter as default } from 'pinstripe';`);
             line();
-            line(`import { defineCommand } from 'pinstripe';`);
+        });
+
+        await generateFile(`lib/commands/${name}.js`, () => {
             line();
-            line(`defineCommand('${dasherize(name)}', () => {`);
+            line(`export default () => {`);
             indent(() => {
                 line(`console.log('${dasherize(name)} command coming soon!')`);
             });
-            line('});');
+            line('};');
             line();
         });
 
     });
-});
+};

package/lib/commands/generate_migration.js

@@ -1,7 +1,5 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-migration', async ({
+export default async ({
     cliUtils: { extractArg, extractFields, extractOptions },
     fsBuilder: { inProjectRootDir, generateFile, line, indent },
     snakeify
@@ -22,11 +20,15 @@ defineCommand('generate-migration', async ({
 
     await inProjectRootDir(async () => {
 
-        await generateFile(`lib/migrations/${name}.js`, () => {
+        await generateFile(`lib/migrations/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { migrationImporter as default } from 'pinstripe';`);
             line();
-            line(`import { defineMigration } from 'pinstripe';`);
+        });
+
+        await generateFile(`lib/migrations/${name}.js`, () => {
             line();
-            line(`defineMigration('${name}', async ({ database }) => {`);
+            line(`export default async ({ database }) => {`);
             indent(() => {
                 line();
                 if(table && fields.length){
@@ -36,8 +38,8 @@ defineCommand('generate-migration', async ({
                     line();
                 }
             })
-            line('});');
+            line('};');
             line();
         });
     });
-});
+};

package/lib/commands/generate_model.js

@@ -1,7 +1,5 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-model', async ({
+export default async ({
     cliUtils: { extractArg, extractFields },
     fsBuilder: { inProjectRootDir, generateFile, line, indent },
     snakeify, pluralize, camelize,
@@ -17,7 +15,7 @@ defineCommand('generate-model', async ({
     const fields = extractFields();
 
     const collectionName = camelize(pluralize(name));
-    if(!await database[collectionName].exists){
+    if(!await database[collectionName].exists()){
         const denormalizedFields = fields.map(({ mandatory, name, type }) => {
             return `${ mandatory ? '^' : '' }${name}:${type}`
         });
@@ -26,17 +24,21 @@ defineCommand('generate-model', async ({
 
     await inProjectRootDir(async () => {
 
-        await generateFile(`lib/models/${name}.js`, () => {
+        await generateFile(`lib/models/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { modelImporter as default } from 'pinstripe';`);
             line();
-            line(`import { defineModel } from 'pinstripe';`);
+        });
+
+        await generateFile(`lib/models/${name}.js`, () => {
             line();
-            line(`defineModel('${name}', {`);
+            line(`export default {`);
             indent(() => {
                 line();
             });
-            line('});');
+            line('};');
             line();
         });
 
     });
-});
+};

package/lib/commands/generate_node_wrapper.js

@@ -0,0 +1,36 @@
+
+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(`}`);
+            });
+            line('};');
+            line();
+        });
+
+    });
+};

package/lib/commands/generate_project.js

@@ -1,9 +1,7 @@
 
 import { spawnSync } from 'child_process';
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-project', async ({
+export default async ({
    cliUtils: { extractArg, extractOptions },
    fsBuilder: { generateDir, generateFile, line, indent, echo }
 }) => {
@@ -43,16 +41,9 @@ defineCommand('generate-project', async ({
          line();
       });
 
-      await generateFile(`lib/web/_importer.js`, () => {
-         line();
-         line(`export { webImporter as default } from 'pinstripe';`);
-         line();
-      });
-
-
       spawnSync('yarn', [ 'add', ...dependencies ], {
          stdio: 'inherit'
       });
 
    });
-});
+};

package/lib/commands/generate_service.js

@@ -1,7 +1,5 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-service', async ({
+export default async ({
     cliUtils: { extractArg },
     fsBuilder: { inProjectRootDir, generateFile, line, indent },
     snakeify, camelize
@@ -14,17 +12,21 @@ defineCommand('generate-service', async ({
 
     await inProjectRootDir(async () => {
 
-        await generateFile(`lib/services/${snakeify(name)}.js`, () => {
+        await generateFile(`lib/services/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { serviceImporter as default } from 'pinstripe';`);
             line();
-            line(`import { defineService } from 'pinstripe';`);
+        });
+
+        await generateFile(`lib/services/${snakeify(name)}.js`, () => {
             line();
-            line(`defineService('${camelize(name)}', () => {`);
+            line(`export default () => {`);
             indent(() => {
                 line(`return 'Example ${camelize(name)} service'`);
             });
-            line('});');
+            line('};');
             line();
         });
 
     });
-});
+};

package/lib/commands/generate_static_site.js

@@ -0,0 +1,79 @@
+
+import { VirtualNode } from '../virtual_node.js';
+import { Url } from '../url.js';
+import { View } from '../view.js';
+import { default as mimeTypes } from 'mime-types';
+
+export default {
+
+    async run(){
+        this.pages = {};
+        const paths = Object.keys(View.classes).filter(path => !path.match(/(^|\/)_/)).map(path => {
+            return `/${path.replace(/(^|\/)index$/, '')}`.replace(/^\/+/, '/');
+        });
+
+        while(paths.length){
+            await this.crawlPage({ _path: paths.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._path;
+                    let filePath = path.replace(/^\//, '');
+                    if(filePath.match(/(^|\/)$/)){
+                        filePath = `${filePath}index`;
+                    }
+                    if(!filePath.match(/[^/]+\.[^/]+$/)){
+                        filePath = `${filePath}.${mimeTypes.extension(contentType)}`
+                    }
+                    
+                    const data = (await this.fetch({ _path: path }))[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 = VirtualNode.fromString(html);
+        const urls = this.extractUrls(virtualDom);
+        while(urls.length){
+            const url = urls.shift();
+            await this.crawlPage({ ...url.params, _path: url.path });
+        }
+    },
+
+    extractUrls(virtualDom){
+        const out = [];
+        virtualDom.traverse(({ attributes }) => {
+            ['src', 'href'].forEach(name => {
+                const value = attributes[name];
+                if(!value) return;
+                const url = Url.fromString(value, 'http://localhost/');
+                if(url.host != 'localhost') return;
+                out.push(url);
+            });
+        });
+        return out;
+    }
+
+};

package/lib/commands/generate_view.js

@@ -1,7 +1,5 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('generate-view', async ({
+export default async ({
     cliUtils: { extractArg },
     fsBuilder: { inProjectRootDir, generateFile, line, indent }
 }) => {
@@ -16,14 +14,14 @@ defineCommand('generate-view', async ({
     }
 
     await inProjectRootDir(async () => {
-        
-        await generateFile(`lib/web/_importer.js`, { skipIfExists: true }, () => {
+
+        await generateFile(`lib/views/_importer.js`, { skipIfExists: true }, () => {
             line();
-            line(`export { webImporter as default } from 'pinstripe';`);
+            line(`export { viewImporter as default } from 'pinstripe';`);
             line();
         });
 
-        await generateFile(`lib/web/${name}`, () => {
+        await generateFile(`lib/views/${name}`, () => {
             line();
             line('export default ({ renderHtml, params }) => renderHtml(`');
             indent(() => {
@@ -33,4 +31,4 @@ defineCommand('generate-view', async ({
             line();
         });
     });
-});
+};

package/lib/commands/init_database.js

@@ -1,8 +1,6 @@
 
-import { defineCommand } from 'pinstripe';
-
-defineCommand('init-database', async ({ runCommand }) => {
+export default async ({ runCommand }) => {
     await runCommand('create-database');
     await runCommand('migrate-database');
     await runCommand('seed-database');
-});
+};

package/lib/commands/list_commands.js

@@ -1,10 +1,9 @@
 
 import chalk from 'chalk';
-import { defineCommand } from 'pinstripe';
 
 import { Command } from '../command.js';
 
-defineCommand('list-commands', () => {
+export default () => {
     console.log('');
     console.log('The following commands are available:');
     console.log('');
@@ -12,4 +11,4 @@ defineCommand('list-commands', () => {
         console.log(`  * ${chalk.green(commandName)}`);
     });
     console.log('');
-});
+};

package/lib/commands/list_migrations.js

@@ -1,10 +1,9 @@
 
 import chalk from 'chalk';
-import { defineCommand } from 'pinstripe';
 
 import { Migration } from '../database/migration.js'
 
-defineCommand('list-migrations', () => {
+export default () => {
     console.log('');
     console.log('The following migrations are available:');
     console.log('');
@@ -12,4 +11,4 @@ defineCommand('list-migrations', () => {
         console.log(`  * ${chalk.green(migrationName)}`);
     });
     console.log('');
-});
+};