pinstripe 0.31.1 → 0.32.0

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

@@ -16,18 +16,6 @@ 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){
                 await context.fork().run(async context => {
                     context.args = [ ...args ];

package/lib/commands/generate_background_job.js

@@ -0,0 +1,47 @@
+
+
+export default {
+    async run(){
+        const [ name = '' ] = this.args;
+        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_project.js

@@ -134,7 +134,7 @@ export default {
             line();
          });
    
-         spawnSync('yarn', [ 'add', ...dependencies ], {
+         spawnSync('npm', [ 'install', ...dependencies ], {
             stdio: 'inherit'
          });
       });

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/run_background_job.js

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

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()];
     }
 };

package/lib/components/pinstripe_frame.js

@@ -47,11 +47,11 @@ export default {
         this.loading = true;
         this.abort();
         const { method = 'GET', placeholderUrl } = options;
-        const cachedHtml = method == 'GET' ? loadCache.get(url.toString()) : undefined;
+        const cachedHtml = method == 'GET' ? loadCache.get(`${this.document.loadCacheNamespace}:${url}`) : undefined;
         if(cachedHtml) this.patch(cachedHtml);
         let minimumDelay = 0;
         if(!cachedHtml && placeholderUrl){
-            const placeholderHtml = loadCache.get(placeholderUrl.toString());
+            const placeholderHtml = loadCache.get(`${this.document.loadCacheNamespace}:${placeholderUrl}`);
             if(placeholderHtml) {
                 this.patch(placeholderHtml);
                 minimumDelay = 300;
@@ -62,7 +62,7 @@ export default {
         this.loading = false;
         if(html == cachedHtml && !this.loadWasBlocked) return;
         this.loadWasBlocked = false;
-        if(method == 'GET') loadCache.put(this.url.toString(), html);
         this.patch(html);
+        if(method == 'GET') loadCache.put(`${this.document.loadCacheNamespace}:${this.url}`, html);
     }
 };

package/lib/components/pinstripe_modal.js

@@ -3,6 +3,8 @@ export default {
     initialize(...args){
         this.constructor.parent.prototype.initialize.call(this, ...args);
 
+        const { width = 'medium', height = 'auto' } = this.params;
+
         this.shadow.patch(`
             <style>
                 .root {
@@ -58,20 +60,37 @@ export default {
                     height: 50%;
                     width: 0.2rem;
                 }
+                .container {
+                    min-height: calc(100vh - 4.0rem);
+                    width: calc(100vw - 16.0rem);
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                }
                 .body {
-                    max-height: calc(100vh - 4.0rem);
-                    max-width: calc(100vw - 16.0rem);
-                    min-width: 64.0rem;
-                    margin: 0 auto;
+                    max-width: 100%;
+                }
+                .root.is-medium-width .body {
+                    width: 800px;
+                }
+                .root.is-full-width .body {
+                    width: 100%;
+                }
+                .root.is-full-height .body {
+                    height: 100%;
                 }
             </style>
-            <div class="root">
+            <div class="root is-${width}-width is-${height}-height">
                 <button class="close-button"></button>
-                <div class="body"><slot></div>
+                <div class="container">
+                    <div class="body">
+                        <slot>
+                    </div>
+                </div>
             </div>
         `);
 
-        this.shadow.on('click', '.root, .close-button', () => this.trigger('close'));
+        this.shadow.on('click', '.root, .container, .body, .close-button', () => this.trigger('close'));
     },
 
     isModal: true

package/lib/database/client.js

@@ -4,6 +4,8 @@ import { existsSync, unlinkSync } from 'fs';
 
 import { Class } from '../class.js';
 
+import { MYSQL_COLUMN_TYPE_TO_TYPE_MAP, SQLITE_COLUMN_TYPE_TO_TYPE_MAP } from './constants.js';
+
 let sqliteConnectionCounters = {};
 let sqliteConnections = {};
 
@@ -143,6 +145,69 @@ export const Client = Class.extend().include({
         const fn = alternatives[adapter];
         if(!fn) throw new Error(`"${adapter}" adapter not supported.`);
         return fn.call(that);
+    },
+
+    async extractSchema(){
+        const out = {};
+
+        const tableNames = await this.adapt(this, {
+            async mysql(){
+                const rows = await this.run('show tables');
+                return rows.map(row => Object.values(row)[0]);
+            },
+
+            async sqlite(){
+                const rows = await this.run(`select name from sqlite_schema where type ='table' and name not like 'sqlite_%'`);
+                return rows.map(({ name }) => name);
+            }
+        });
+    
+        while(tableNames.length){
+            const tableName = tableNames.shift();
+            const columns = await this.adapt(this, {
+                async mysql(){
+                    const out = {};
+                    const rows = await this.run(`describe \`${tableName}\``);
+                    rows.forEach(row => {
+                        const name = row['Field'];
+                        let type;
+                        if(name == '_id'){
+                            type = 'primary_key';
+                        } else if(name == 'id'){
+                            type = 'alternate_key';
+                        } else {
+                            type = MYSQL_COLUMN_TYPE_TO_TYPE_MAP[row['Type']] || 'string';
+                        }
+                        
+                        out[name] = type;
+                    });
+                    return out;
+                },
+
+                async sqlite(){
+                    const out = {};
+                    const rows = await this.run(`pragma table_info(\`${tableName}\`)`);
+                    rows.forEach(row => {
+                        const { name } = row;
+                        let type;
+                        if(name == '_id'){
+                            type = 'primary_key';
+                        } else if(name == 'id'){
+                            type = 'alternate_key';
+                        } else if(name.match(/.+Id$/)){
+                            type = 'foreign_key';
+                        } else {
+                            type = SQLITE_COLUMN_TYPE_TO_TYPE_MAP[row.type] || 'string';
+                        }
+                        out[name] = type;
+                    });
+                    return out;
+                }
+            });
+            out[tableName] = columns;
+        }
+
+        return out;
     }
 });
 

package/lib/database/constants.js

@@ -46,7 +46,7 @@ export const SQLITE_COLUMN_TYPE_TO_TYPE_MAP = (() => {
     return out;
 })();
 
-export const COMPARISON_OPERATORS = {
+export const MYSQL_COMPARISON_OPERATORS = {
     '': '? = ?',
     Ne: '? != ?',
     Lt: '? < ?',
@@ -58,6 +58,18 @@ export const COMPARISON_OPERATORS = {
     Contains: `? like concat('%', ?, '%')`
 };
 
+export const SQLITE_COMPARISON_OPERATORS = {
+    '': '? = ?',
+    Ne: '? != ?',
+    Lt: '? < ?',
+    Gt: '? > ?',
+    Le: '? <= ?',
+    Ge: '? >= ?',
+    BeginsWith: `? like (? || '%')`,
+    EndsWith: `? like ('%' || ?)`,
+    Contains: `? like ('%' || ? || '%')`
+};
+
 export const MYSQL_KEY_COMPARISON_OPERATORS = {
     '': '? = uuid_to_bin(?)',
     Ne: '? != uuid_to_bin(?)'

package/lib/database/row.js

@@ -18,15 +18,6 @@ export const Row = Model.extend().include({
         defineCallbacks.call(this, 'beforeInsert', 'afterInsert', 'beforeUpdate', 'afterUpdate', 'beforeDelete', 'afterDelete')
 
         this.assignProps({
-
-            async loadSchema(client){
-                await Table.loadSchema(client);
-                this.clearCache();
-                this.names.forEach(name => this.for(name));
-                Table.clearCache();
-                Table.names.forEach(name => Table.for(name));
-            },
-
             normalizeName(name){
                 return inflector.camelize(name);
             },
@@ -61,11 +52,7 @@ export const Row = Model.extend().include({
             includeInTable(...args){
                 if(this.abstract) return;
 
-                Table.register(this.collectionName, {
-                    meta(){
-                        this.include(...args);
-                    }
-                });
+                Table.for(this.collectionName).include(...args);
             },
 
             scope(...args){
@@ -110,6 +97,16 @@ export const Row = Model.extend().include({
                     cascadeDelete: false,
                     ...options
                 });
+            },
+
+            mustBeUnique(name, options = {}){
+                const { message = 'Must be unique', collection = this.collectionName } = options;
+                return this.validateWith(async row => {
+                    if(row.isValidationError(name)) return;
+                    const value = row[name];
+                    const alreadyExists = await row.database[collection].where({ [name]: value, idNe: row.id }).count() > 0;
+                    if(alreadyExists) row.setValidationError(name, message);
+                });
             }
         });
     },
@@ -153,13 +150,15 @@ export const Row = Model.extend().include({
                     modifiedFields[name] = this[name];
                 }
             });
+
+            const exists =  this._exists;
             
             if(Object.keys(modifiedFields).length) {
                 const query = [];
 
                 const tableReference = TableReference.new(this.constructor.collectionName);
 
-                if(this._exists){
+                if(exists){
                     query.push('update ? set ', tableReference);
                     Object.keys(modifiedFields).forEach((name, i) => {
                         if(name == 'id') return;
@@ -186,7 +185,6 @@ export const Row = Model.extend().include({
                             query.push(' where ? = ?', tableReference.createColumnReference('id'), this._initialFields.id);
                         }
                     });
-                    
                 } else {
                     query.push('insert into ?(', tableReference);
                     Object.keys(modifiedFields).forEach((name, i) => {
@@ -227,10 +225,9 @@ export const Row = Model.extend().include({
                 });
 
                 this._exists = true;
-
             }
 
-            await (this._exists ? this._runAfterUpdateCallbacks() : this._runAfterInsertCallbacks());
+            await (exists ? this._runAfterUpdateCallbacks() : this._runAfterInsertCallbacks());
 
             return this;
         });
@@ -272,10 +269,7 @@ export const Row = Model.extend().include({
         const names = [...new Set([ ...Object.keys(columns), ...extractSettableProps(this) ])];
         while(names.length){
             const name = names.shift();
-            let value = await this[name];
-            if(typeof value?.toFieldValue == 'function'){
-                value = await value.toFieldValue();
-            }
+            const value = await this[name];
             const type = columns[name] ? columns[name] : typeof value;
             fields.push({
                 name,
@@ -300,7 +294,8 @@ export const Row = Model.extend().include({
 
 function defineRelationship({ name, type, collectionName, fromKey, toKey, cascadeDelete, through }){
     if(this.abstract) return;
-    Table.register(this.collectionName, {
+
+    this.includeInTable({
         meta(){
             this.prototype.assignProps({
                 get [name](){