pinstripe 0.31.1 → 0.33.0

package/cli.js

@@ -1,46 +1,36 @@
 #!/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);
+    const { entryPath, exists } = await Project.instance;
+    const { argv } = process;
+    const [name, ...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);
-        }
+    if(entryPath){
+        import(entryPath);
+    }
 
-        await importAll();
+    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);
-        }
+    if(exists){
+        Command.names.forEach(commandName => {
+            if(!Command.for(commandName).internal) Command.unregister(commandName);
+        });
+    } else {
+        Command.names.forEach(commandName => {
+            if(!Command.for(commandName).external) Command.unregister(commandName);
+        });
+    }
+    
+    try {
+        await Workspace.run(async function(){
+            await this.runCommand(name, args);
+        });
+    } catch(e) {
+        console.error(e);
     }
 })();

package/lib/background_job.js

@@ -0,0 +1,42 @@
+
+import { Class } from './class.js';
+import { inflector } from './inflector.js';
+import { Registry } from './registry.js';
+import { ServiceConsumer } from './service_consumer.js';
+
+export const BackgroundJob = Class.extend().include({
+    meta(){
+        this.assignProps({ name: 'BackgroundJob' });
+
+        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){
+                await context.fork().run(async context => {
+                    await this.create(name, context).run();
+                });
+            },
+        });
+    },
+
+    run(){
+        console.error(`No such background job "${this.constructor.name}" exists.`);
+    }
+});

package/lib/background_jobs/_file_importer.js

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

package/lib/{commands → background_jobs}/purge_used_hashes.js

@@ -4,10 +4,8 @@ export default {
         this.schedule('*/5 * * * *');
     },
 
-    minutesUntilExpiry: 30,
-
     async run(){
-        await this.database.withoutTenantScope.usedHashes.where({
+        await this.database.usedHashes.where({
             expiresAtLt: new Date()
         }).delete();
     }

package/lib/command.js

@@ -4,9 +4,15 @@ import { inflector } from './inflector.js';
 import { Registry } from './registry.js';
 import { ServiceConsumer } from './service_consumer.js';
 
+const optionPattern = /^-([a-z]|-[a-z\-]+)$/;
+
 export const Command = Class.extend().include({
     meta(){
-        this.assignProps({ name: 'Command' });
+        this.assignProps({ 
+            name: 'Command',
+            internal: true,
+            external: false
+        });
 
         this.include(Registry);
         this.include(ServiceConsumer);
@@ -16,24 +22,43 @@ export const Command = Class.extend().include({
                 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){
+            async run(context, name = 'list-commands', params = {}){
                 await context.fork().run(async context => {
-                    context.args = [ ...args ];
+                    context.params = Array.isArray(params) ? this.extractParams(params) : params;
                     await this.create(name, context).run();
                 });
             },
+
+            extractParams(_args = []){
+                const args = [ ..._args ];
+                const out = {};
+                let currentName;
+                while(args.length){
+                    const arg = args.shift();
+                    const matches = arg.match(optionPattern);
+                    if(matches){
+                        currentName = inflector.camelize(matches[1]);
+                        if(out[currentName] === undefined){
+                            out[currentName] = [];
+                        }
+                    } else {
+                        if(currentName === undefined){
+                            currentName = 'args';
+                            out[currentName] = [];
+                        }
+                        out[currentName].push(arg);
+                    }
+                }
+                Object.keys(out).forEach(name => {
+                    const value = out[name];
+                    if(!value.length){
+                        out[name] = true;
+                    } else {
+                        out[name] = value.join(' ');
+                    }
+                });
+                return out;
+            }
         });
     },
 

package/lib/command.test.js

@@ -0,0 +1,32 @@
+import { Command } from "./command.js";
+
+[
+    { args: [], expectedParams: {} },
+    { args: ["-a"], expectedParams: { a: true } },
+    { args: ["--apple"], expectedParams: { apple: true } },
+    { args: ["--apple", "--pear"], expectedParams: { apple: true, pear: true } },
+    { args: ["Hello world!"], expectedParams: { args: "Hello world!" } },
+    { args: ["Hello", "world!"], expectedParams: { args: "Hello world!" } },
+    {
+        args: [
+            "Hello", "world!",
+            "--apple",
+            "--pear",
+            "--plum-color", "purple",
+            "--other-fruit", "peach", "orange",
+        ],
+        expectedParams: {
+            args: "Hello world!",
+            apple: true,
+            pear: true,
+            plumColor: "purple",
+            otherFruit: "peach orange",
+        },
+    },
+].forEach(({ args, expectedParams }, i) => {
+    test(`Command.extractParams (${i}})`, () => {
+        expect(Command.extractParams(args)).toStrictEqual(expectedParams);
+    });
+});
+
+

package/lib/commands/generate_app.js

@@ -2,10 +2,10 @@
 
 export default {
     async run(){
-        const [ name = '' ] = this.args;
+        const { name = '' } = this.params;
         const normalizedName = this.inflector.snakeify(name);
         if(normalizedName == ''){
-            console.error('An app name must be given.');
+            console.error('An app --name must be given.');
             process.exit();
         }
 
@@ -35,7 +35,9 @@ export default {
     
         });
 
-        await this.runCommand('generate-view', `${normalizedName}/index`);
+        await this.runCommand('generate-view', {
+            name: `${normalizedName}/index`
+        });
     }
 }
 

package/lib/commands/generate_background_job.js

@@ -0,0 +1,47 @@
+
+
+export default {
+    async run(){
+        const { name = '' } = this.params;
+        const normalizedName = this.inflector.snakeify(name);
+        if(normalizedName == ''){
+            console.error('A background job --name must be given.');
+            process.exit();
+        }
+
+        const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/background_jobs/_file_importer.js`, { skipIfExists: true }, () => {
+                line();
+                line(`export { BackgroundJob as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/background_jobs/${normalizedName}.js`, () => {
+                line();
+                line(`export default {`);
+                indent(() => {
+                    line('meta(){');
+                    indent(() => {
+                        line(`this.schedule('* * * * *'); // run every minute`);
+                    });
+                    line('}');
+                });
+                line();
+                indent(() => {
+                    line('run(){');
+                    indent(() => {
+                        line(`console.log('${this.inflector.dasherize(normalizedName)} background job coming soon!')`);
+                    });
+                    line('}');
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+}
+

package/lib/commands/generate_command.js

@@ -2,10 +2,10 @@
 
 export default {
     async run(){
-        const [ name = '' ] = this.args;
+        const { name = '' } = this.params;
         const normalizedName = this.inflector.snakeify(name);
         if(normalizedName == ''){
-            console.error('A command name must be given.');
+            console.error('A command --name must be given.');
             process.exit();
         }
 

package/lib/commands/generate_component.js

@@ -1,10 +1,9 @@
 
 export default {
     async run(){
-        const { extractArg } = this.cliUtils;
-        const name = this.inflector.snakeify(extractArg(''));
+        const name = this.inflector.snakeify(this.params.name || '');
         if(name == ''){
-            console.error('A component name must be given.');
+            console.error('A component --name must be given.');
             process.exit();
         }
     

package/lib/commands/generate_migration.js

@@ -1,18 +1,18 @@
 
 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 suffix = this.inflector.snakeify(this.params.suffix || 'migration');
+
+        const { fields = '' } = this.params;
+        const normalizedFields = this.cliUtils.normalizeFields(fields);
+        
+        const table = this.params.table || (() => {
+            const matches = suffix.match(/_to_(.+)$/);
+            if(matches){
+                return matches[1];
+            }
+        })();
 
         const unixTime = Math.floor(new Date().getTime() / 1000);
         const name = `${unixTime}_${suffix}`;
@@ -33,10 +33,10 @@ export default {
                 indent(() => {
                     line(`async migrate(){`);
                     indent(() => {
-                        if(table && fields.length){
+                        if(table && normalizedFields.length){
                             line(`await this.database.table('${table}', async ${table} => {`);
                             indent(() => {
-                                fields.forEach(({ name, type }) => {
+                                normalizedFields.forEach(({ name, type }) => {
                                     line(`await ${table}.addColumn('${name}', '${type}');`);
                                 });
                             })

package/lib/commands/generate_model.js

@@ -2,20 +2,17 @@
 export default {
     async run(){
 
-        const { extractArg, extractFields } = this.cliUtils;
-        const name = this.inflector.snakeify(extractArg(''));
+        const name = this.inflector.snakeify(this.params.name || '');
         if(name == ''){
-            console.error('A model name must be given.');
+            console.error('A model --name must be given.');
             process.exit();
         }
-        const fields = extractFields();
-    
+
+        let { fields = '' } = this.params;
+
         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)
+            await this.runCommand('generate-migration', { name: `create_${name}`, fields, table: collectionName});
         }
     
         const { inProjectRootDir, generateFile, line, indent } = this.fsBuilder;

package/lib/commands/generate_project.js

@@ -7,18 +7,23 @@ const defaultDependencies = [
 ];
 
 export default {
-   async run(){
+   meta(){
+      this.assignProps({
+          external: true,
+          internal: false
+      });
+  },
 
-      const { extractArg, extractOptions } = this.cliUtils;
-      const name = extractArg('');
+   async run(){
+      const name = this.params.name || '';
       if(name == ''){
-         console.error('A project name must be given.');
+         console.error('A project --name must be given.');
          process.exit();
       }
-      const { with: dependencies, core } = extractOptions({
-         with: [],
-         core: false
-      });
+
+      let { with: dependencies = '', core = false } = this.params;
+
+      dependencies = dependencies.split(/\s+/).map(dependency => dependency.trim());
 
       if(!core) defaultDependencies.forEach(dependency => {
          if(!dependencies.includes(dependency)) dependencies.unshift(dependency);
@@ -134,7 +139,7 @@ export default {
             line();
          });
    
-         spawnSync('yarn', [ 'add', ...dependencies ], {
+         spawnSync('npm', [ 'install', ...dependencies ], {
             stdio: 'inherit'
          });
       });

package/lib/commands/generate_service.js

@@ -1,9 +1,9 @@
 
 export default {
     async run(){
-        const [ name = '' ] = this.args;
+        const { name = '' } = this.params;
         if(name == ''){
-            console.error('A service name must be given.');
+            console.error('A service --name must be given.');
             process.exit();
         }
     

package/lib/commands/generate_static_site.js

@@ -6,9 +6,7 @@ import { App, View } from 'pinstripe';
 export default {
     async run(){
 
-        const { extractOptions } = this.cliUtils;
-
-        const { app = 'main' } = extractOptions();
+        const { app = 'main' } = this.params;
 
         const { viewNames } = View.mapperFor(App.create(app, this.context).compose());
 

package/lib/commands/generate_view.js

@@ -4,10 +4,10 @@ import { readFile } from 'fs/promises';
 
 export default {
     async run(){
-        const [ name = '' ] = this.args;
+        const { name = '' } = this.params;
         let normalizedName = name.replace(/^\//, '');
         if(name == ''){
-            console.error('A view name must be given.');
+            console.error('A view --name must be given.');
             process.exit();
         }
 

package/lib/commands/list_background_jobs.js

@@ -0,0 +1,15 @@
+
+import chalk from 'chalk';
+import { BackgroundJob } from 'pinstripe';
+
+export default {
+    run(){
+        console.log('');
+        console.log('The following background jobs are available:');
+        console.log('');
+        BackgroundJob.names.forEach(backgroundJobName => {
+            console.log(`  * ${chalk.green(backgroundJobName)}`);
+        });
+        console.log('');
+    }
+};

package/lib/commands/list_commands.js

@@ -3,6 +3,12 @@ import chalk from 'chalk';
 import { Command } from 'pinstripe';
 
 export default {
+    meta(){
+        this.assignProps({
+            external: true,
+        });
+    },
+
     run(){
         console.log('');
         console.log('The following commands are available:');

package/lib/commands/list_views.js

@@ -4,9 +4,7 @@ import { App, View } from 'pinstripe';
 
 export default {
     run(){
-        const { extractOptions } = this.cliUtils;
-
-        const { app = 'main' } = extractOptions();
+        const { app = 'main' } = this.params;
 
         const { viewNames } = View.mapperFor(App.create(app, this.context).compose());
         console.log('');

package/lib/commands/run_background_job.js

@@ -0,0 +1,11 @@
+
+export default {
+    async run(){
+        const { name = '' } = this.params;
+        if(name == ''){
+            console.error('A background job --name must be given.');
+            process.exit();
+        }
+        this.runBackgroundJob(name);
+    }
+};

package/lib/commands/start_server.js

@@ -1,13 +1,10 @@
 
 export default {
     run(){
-        const { extractOptions } = this.cliUtils;
-
-        const { app, withoutBot } = extractOptions({
-            app: `main:${process.env.HOST || '127.0.0.1'}:${parseInt(process.env.PORT || '3000')}`,
-            withoutBot: false
-        });
-
+        const {
+            app = `main:${process.env.HOST || '127.0.0.1'}:${parseInt(process.env.PORT || '3000')}`, 
+            withoutBot = false
+        } = this.params;
         
         const apps = [];
         let currentPort = 3000;

package/lib/component.js

@@ -203,7 +203,7 @@ export const Component = Class.extend().include({
     },
 
     get isInput(){
-        return this.is('input, textarea');
+        return this.is('input, textarea, select');
     },
 
     get name(){
@@ -220,6 +220,9 @@ export const Component = Class.extend().include({
         if(this.is('input[type="checkbox"]')){
             return this.is(':checked') ? true : false;
         }
+        if(this.is('select')){
+            return this.findAll('option').map(option => option.value)[this.node.selectedIndex];
+        }
         return this.node.value;
     },
 
@@ -597,14 +600,14 @@ function patchAttributes(attributes){
             if(attributes[key] === undefined){
                 Element.prototype.removeAttribute.call(this.node, key); // work around for https://github.com/cypress-io/cypress/issues/26206
                 // this.node.removeAttribute(key);
+                if(key == 'checked') this.node.checked = false;
             }
         })
         Object.keys(attributes).forEach((key) => {
             if(!currentAttributes.hasOwnProperty(key) || currentAttributes[key] != attributes[key]){
                 this.node.setAttribute(key, attributes[key]);
-                if(key == 'value'){
-                    this.node.value = attributes[key];
-                }
+                if(key == 'value') this.node.value = attributes[key];
+                if(key == 'checked') this.node.checked = true;
             }
         })
     }

package/lib/components/helpers.js

@@ -51,11 +51,23 @@ export function normalizeUrl(url, referenceUrl = window.location){
     const matches = `${url}`.match(/^&(.*)$/);
     const out = matches ? new URL(referenceUrl) : new URL(url, referenceUrl);
     if(matches){
-        if(out.search){
-            out.search = `${out.search}&${matches[1]}`;
-        } else {
-            out.search = `?${matches[1]}`;
-        }
+        out.search = `?${stringifyUrlSearch({
+            ...parseUrlSearch(out.search),
+            ...parseUrlSearch(`${matches[1]}`)
+        })}`;
     }
     return out;
-}
+}
+
+function parseUrlSearch(search){
+    const out = {};
+    search.replace(/^\?/, '').split('&').forEach(pair => {
+        const [key, value] = pair.split('=');
+        out[decodeURIComponent(key)] = decodeURIComponent(value);
+    });
+    return out;
+}
+
+function stringifyUrlSearch(search){
+    return Object.keys(search).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(search[key])}`).join('&');
+}

package/lib/components/pinstripe_document.js

@@ -47,6 +47,10 @@ export default {
         return this.body.progressBar;
     },
 
+    get loadCacheNamespace(){
+        return this.head.find('meta[name="pinstripe-load-cache-namespace"]')?.params.content ?? 'default';
+    },
+
     async load(url = this.url.toString(), options = {}){
         const { replace, method = 'GET' } = options;
         const previousUrl = this.url.toString();
@@ -65,12 +69,12 @@ export default {
     },
 
     async preload(url){
-        if(loadCache.get(url.toString())) return;
+        if(loadCache.get(`${this.document.loadCacheNamespace}:${url}`)) return;
         if(preloading[url.toString()]) return;
         preloading[url.toString()] = true;
         const response = await fetch(url);
         const html = await response.text();
-        loadCache.put(url.toString(), html);
+        loadCache.put(`${this.document.loadCacheNamespace}:${url}`, html);
         delete preloading[url.toString()];
     }
 };