pinstripe 0.7.0 → 0.11.0

package/lib/commands/generate_service.js

@@ -0,0 +1,32 @@
+
+export default async ({
+    cliUtils: { extractArg },
+    fsBuilder: { inProjectRootDir, generateFile, line, indent },
+    snakeify, camelize
+}) => {
+    const name = extractArg('');
+    if(name == ''){
+        console.error('A service name must be given.');
+        process.exit();
+    }
+
+    await inProjectRootDir(async () => {
+
+        await generateFile(`lib/services/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { serviceImporter as default } from 'pinstripe';`);
+            line();
+        });
+
+        await generateFile(`lib/services/${snakeify(name)}.js`, () => {
+            line();
+            line(`export default () => {`);
+            indent(() => {
+                line(`return 'Example ${camelize(name)} service'`);
+            });
+            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

@@ -0,0 +1,34 @@
+
+export default async ({
+    cliUtils: { extractArg },
+    fsBuilder: { inProjectRootDir, generateFile, line, indent }
+}) => {
+    let name = extractArg('').replace(/^\//, '');
+    if(name == ''){
+        console.error('A view name must be given.');
+        process.exit();
+    }
+
+    if(!name.match(/\.[^\/]+$/)){
+        name = `${name}.tpl.js`;
+    }
+
+    await inProjectRootDir(async () => {
+
+        await generateFile(`lib/views/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { viewImporter as default } from 'pinstripe';`);
+            line();
+        });
+
+        await generateFile(`lib/views/${name}`, () => {
+            line();
+            line('export default ({ renderHtml, params }) => renderHtml(`');
+            indent(() => {
+                line(`<h1>${name} view<h1></h1>`);
+            });
+            line('`);');
+            line();
+        });
+    });
+};

package/lib/commands/generate_widget.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 widget name must be given.');
+        process.exit();
+    }
+
+    await inProjectRootDir(async () => {
+
+        await generateFile(`lib/widgets/_importer.js`, { skipIfExists: true }, () => {
+            line();
+            line(`export { widgetImporter as default } from 'pinstripe';`);
+            line();
+        });
+
+        await generateFile(`lib/widgets/${name}.client.js`, () => {
+            line();
+            line(`export default {`);
+            indent(() => {
+                line(`initialize(...args){`);
+                    indent(() => {
+                        line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
+                    });
+                line(`}`);
+            });
+            line('};');
+            line();
+        });
+
+    });
+};

package/lib/commands/init_database.js

@@ -0,0 +1,6 @@
+
+export default async ({ runCommand }) => {
+    await runCommand('create-database');
+    await runCommand('migrate-database');
+    await runCommand('seed-database');
+};

package/lib/commands/list_commands.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { Command } from '../command.js';
+
+export default () => {
+    console.log('');
+    console.log('The following commands are available:');
+    console.log('');
+    Object.keys(Command.classes).sort().forEach(commandName => {
+        console.log(`  * ${chalk.green(commandName)}`);
+    });
+    console.log('');
+};

package/lib/commands/list_migrations.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { Migration } from '../database/migration.js'
+
+export default () => {
+    console.log('');
+    console.log('The following migrations are available:');
+    console.log('');
+    Object.keys(Migration.classes).sort().forEach(migrationName => {
+        console.log(`  * ${chalk.green(migrationName)}`);
+    });
+    console.log('');
+};

package/lib/commands/list_models.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { Row } from '../database/row.js';
+
+export default () => {
+    console.log('');
+    console.log('The following models are available:');
+    console.log('');
+    Object.keys(Row.classes).sort().forEach(modelName => {
+        console.log(`  * ${chalk.green(modelName)}`);
+    });
+    console.log('');
+};

package/lib/commands/list_services.js

@@ -0,0 +1,15 @@
+
+import chalk from 'chalk';
+
+import { ServiceFactory } from '../service_factory.js';
+
+export default () => {
+    console.log('');
+    console.log('The following services are available:');
+    console.log('');
+    Object.keys(ServiceFactory.classes).sort().forEach(serviceName => {
+        console.log(`  * ${chalk.green(serviceName)}`);
+    });
+    console.log('');
+};
+

package/lib/commands/list_views.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { View } from '../view.js';
+
+export default () => {
+    console.log('');
+    console.log('The following views are available:');
+    console.log('');
+    Object.keys(View.classes).sort().forEach(viewName => {
+        console.log(`  * ${chalk.green(viewName)}`);
+    });
+    console.log('');
+};

package/lib/commands/list_widgets.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { NodeWrapper } from '../node_wrapper.js';
+
+export default () => {
+    console.log('');
+    console.log('The following widgets are available:');
+    console.log('');
+    Object.keys(NodeWrapper.classes).filter(widgetName => !NodeWrapper.classes[widgetName].isPrivate).sort().forEach(widgetName => {
+        console.log(`  * ${chalk.green(widgetName)}`);
+    });
+    console.log('');
+};

package/lib/commands/migrate_database.js

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

package/lib/commands/reset_database.js

@@ -0,0 +1,5 @@
+
+export default async ({ runCommand }) => {
+    await runCommand('drop-database');
+    await runCommand('init-database');
+};

package/lib/commands/seed_database.js

@@ -0,0 +1,4 @@
+
+export default () => {
+    // do nothing
+};

package/lib/commands/{start_console.server.js → start_console.js}

@@ -2,11 +2,11 @@
 import * as Repl from 'repl';
 import * as vm from 'vm';
 import * as util from 'util';
-import { ServiceFactory } from 'pinstripe';
 
-export default Class => Class.props({
-    run(){
-        const { environment, resetEnvironment } = this;
+import { ServiceFactory } from '../service_factory.js';
+
+export default async ({ environment, resetEnvironment }) => {
+    await new Promise(resolve => {
         const repl = Repl.start({
             prompt: 'pinstripe > ',
 
@@ -43,6 +43,7 @@ export default Class => Class.props({
             })
         );
 
-        repl.on('exit', resetEnvironment);
-    }
-});
+        repl.on('exit', resolve);
+    });
+    await resetEnvironment();
+};

package/lib/commands/start_server.js

@@ -0,0 +1,76 @@
+
+import http from 'http';
+import Busboy from 'busboy';
+import { default as qs} from 'qs';
+const { parse: parseQueryString } = qs;
+
+export default async ({ fetch }) => {
+    const host = process.env.HOST || '127.0.0.1';
+    const port = process.env.PORT || 3000;
+
+    http.createServer(async (request, response) => {
+        try {
+            const params = await extractParams(request);
+            const [ status, headers, body ] = await fetch(params);
+            response.statusCode = status
+            Object.keys(headers).forEach(
+                (name) => response.setHeader(name, headers[name])
+            )
+            body.forEach(chunk => response.write(chunk));
+            response.end();
+        } catch (e){
+            response.statusCode = 500;
+            response.setHeader('content-type', 'text/plain');
+            response.end((e.stack || e).toString());
+        }
+        console.log(`${request.method}: ${request.url} (${response.statusCode})`);
+    }).listen(port, host, () => {
+        console.log(`Pinstripe running at http://${host}:${port}/`)
+    });
+};
+
+const extractParams = async (request) => {
+    const { method, url, headers } = request;
+    const matches = url.match(/^([^\?]+)\?(.*)$/);
+    const path = matches ? matches[1] : url;
+    const queryString = parseQueryString(matches ? matches[2] : "");
+    const body = method.match(/^POST|PUT|PATCH$/) ? await parseBody(request) : {};
+    
+    return {
+        ...queryString,
+        ...body,
+        _method: method,
+        _path: path,
+        _headers: headers
+    };
+};
+
+const parseBody = (request) => new Promise((resolve) => {
+    const out = {};
+    const busboy = new Busboy({ headers: request.headers });
+
+    busboy.on('file', function(fieldname, file, filename, encoding, mimeType) {
+        const chunks = [];
+
+        file.on('data', chunk => {
+            chunks.push(Buffer.from(chunk));
+        });
+
+        file.on('end', () => {
+            out[fieldname] = {
+                filename,
+                encoding,
+                mimeType,
+                data: Buffer.concat(chunks)
+            };
+        });
+    });
+
+    busboy.on('field', (fieldname, value) => {
+        out[fieldname] = value
+    });
+
+    busboy.on('finish', () => resolve(out));
+
+    request.pipe(busboy);
+});

package/lib/constants.js

@@ -0,0 +1,21 @@
+
+export const SELF_CLOSING_TAGS = [
+    'area',
+    'base',
+    'br',
+    'embed',
+    'hr',
+    'iframe',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track'
+];
+
+export const TEXT_ONLY_TAGS = [
+    'script',
+    'style'
+];

package/lib/database/column.js

@@ -0,0 +1,94 @@
+
+import { Base } from "../base.js";
+import { Sql } from './sql.js';
+import { TYPE_TO_MYSQL_COLUMN_TYPE_MAP, TYPE_TO_DEFAULT_VALUE_MAP } from './constants.js';
+
+export const Column = Base.extend().include({
+    initialize(table, name, type){
+        this._table = table;
+        this._name = name;
+        this._type = type;
+    },
+
+    get sql(){
+        return Sql.fromTemplate(this);
+    },
+
+    toSql(){
+        return this.sql`${this._table}.${Sql.escapeIdentifier(this._name)}`;
+    },
+
+    async type(){
+        if(!this._type){
+            this._type = (await this._table[this._name])._type;
+        }
+        return this._type;
+    },
+
+    async exists(){
+        return (await this.type()) !== undefined;
+    },
+
+    async create(type = 'string', options = {}){
+        options = {
+            index: type == 'foreign_key',
+            default: TYPE_TO_DEFAULT_VALUE_MAP[type],
+            ...options
+        };
+        const table = this._table;
+        const database = table._database;
+
+        await table.create();
+
+        if(!await this.exists()){
+            await database.run`
+                alter table ${table.constructor}
+                add column ${Sql.escapeIdentifier(this._name)} ${[TYPE_TO_MYSQL_COLUMN_TYPE_MAP[type]]}
+                ${options.default !== undefined ? this.sql`default ${options.default}` : undefined}
+            `;
+        }
+
+        if(options.index){
+            await database.run`
+                alter table ${table.constructor}
+                add index(${Sql.escapeIdentifier(this._name)})
+            `;
+        }
+
+        return this;
+    },
+
+    async drop(){
+        const table = this._table;
+        const database = table._database;
+
+        if(await this.exists()){
+            await database.run`
+                alter table ${table.constructor}
+                drop ${Sql.escapeIdentifier(this._name)}
+            `;
+            this._type = undefined;
+        }
+
+        return this;
+    },
+
+    async __beforeInspect(){
+        const exists = await this.exists();
+        this._inspectInfo = {
+            exists,
+            ...(() => {
+                if(exists){
+                    return {
+                        type: this._type
+                    };
+                }
+                return {};
+            })()
+        };
+    },
+
+    __inspect(){
+        return `${this._name} (Column) ${JSON.stringify(this._inspectInfo, null, 2)}`;
+    }
+});

package/lib/database/constants.js

@@ -0,0 +1,84 @@
+
+export const TYPE_TO_MYSQL_COLUMN_TYPE_MAP = {
+    primary_key: "int(11) unsigned",
+    alternate_key: "binary(16)",
+    foreign_key: "binary(16)",
+    binary: "longblob",
+    boolean: "enum('false','true')",
+    date: "date",
+    datetime: "datetime",
+    decimal: "decimal",
+    float: "float",
+    integer: "int(11)",
+    string: "varchar(255)",
+    text: "longtext",
+    time: "time",
+    timestamp: "datetime"
+};
+
+export const ALLOWED_TABLE_ADAPTER_COLUMN_TYPES = [
+    'boolean',
+    'date',
+    'datetime',
+    'decimal',
+    'float',
+    'integer',
+    'string',
+    'time',
+    'timestamp'
+];
+
+export const TYPE_TO_DEFAULT_VALUE_MAP = {
+    boolean: false,
+    decimal: 0,
+    float: 0,
+    integer: 0,
+    string: ''
+};
+
+export const MYSQL_COLUMN_TYPE_TO_TYPE_MAP = (() => {
+    const out = {};
+    Object.keys(TYPE_TO_MYSQL_COLUMN_TYPE_MAP).forEach(
+        key => out[TYPE_TO_MYSQL_COLUMN_TYPE_MAP[key]] = key
+    );
+    return out;
+})();
+
+
+export const COMPARISON_OPERATORS = {
+    Eq: (column, value) => column.sql`${column} = ${value}`,
+    Ne: (column, value) => column.sql`${column} != ${value}`,
+    Lt: (column, value) => column.sql`${column} < ${value}`,
+    Gt: (column, value) => column.sql`${column} > ${value}`,
+    Le: (column, value) => column.sql`${column} <= ${value}`,
+    Ge: (column, value) => column.sql`${column} >= ${value}`,
+    BeginsWith: (column, value) => column.sql`${column} like concat(${value}, '%')`,
+    EndsWith: (column, value) => column.sql`${column} like concat('%', ${value})`,
+    Contains: (column, value) => column.sql`${column} like concat('%', ${value}, '%')`
+};
+
+export const KEY_COMPARISON_OPERATORS = {
+    Eq: (column, value) => column.sql`${column} = uuid_to_bin(${value})`,
+    Ne: (column, value) => column.sql`${column} != uuid_to_bin(${value})`
+};
+
+export const COMPARISON_OPERATOR_METHOD_PATTERN = new RegExp(`^(.+)(${Object.keys(COMPARISON_OPERATORS).join('|')})$`);
+export const KEY_COMPARISON_OPERATOR_METHOD_PATTERN = new RegExp(`^(id|.+Id)(${Object.keys(KEY_COMPARISON_OPERATORS).join('|')})$`);
+
+export const COLUMN_TYPE_TO_FORM_FIELD_TYPE_MAP = {
+    primary_key: "hidden",
+    alternate_key: "hidden",
+    foreign_key: "hidden",
+    binary: "file",
+    boolean: "checkbox",
+    date: "date",
+    datetime: "datetime-local",
+    decimal: "number",
+    float: "number",
+    integer: "number",
+    string: "text",
+    text: "textarea",
+    time: "datetime-local",
+    timestamp: "datetime-local"
+};
+

package/lib/database/migration.js

@@ -0,0 +1,74 @@
+
+
+import { Base } from '../base.js';
+import { Registrable } from '../registrable.js';
+import { overload } from '../overload.js';
+import { thatify } from '../thatify.js';
+import { addFileToClient } from '../client.js';
+
+export const Migration = Base.extend().include({
+    meta(){
+        this.include(Registrable);
+
+        const { register } = this;
+
+        this.assignProps({
+            register(name){
+                if(!name.match(/^\d+/)){
+                    throw new Error(`Invalid migration name '${name}' - it must begin with a unix timestamp`);
+                }
+                return register.call(this, name);
+            },
+            get schemaVersion(){
+                const matches = this.name.match(/^\d+/)
+                if(matches){
+                    return parseInt(matches[0]);
+                }
+                return 0;
+            }
+        });
+    },
+    
+    initialize(environment){
+        this.environment = environment;
+    },
+
+    migrate(){
+        
+    },
+
+    __getMissing(name){
+        return this.environment[name];
+    }
+});
+
+export const defineMigration = overload({
+    ['string, object'](name, include){
+        const abstract = include.abstract;
+        delete include.abstract;
+        Migration.register(name, abstract).include(include);
+    },
+
+    ['string, function'](name, fn){
+        defineMigration(name, { migrate: thatify(fn) });
+    }
+});
+
+export const migrationImporter = 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){
+                defineMigration(relativeFilePathWithoutExtension, definition);
+            }
+            return;
+        }
+    };
+};