pinstripe 0.29.0 → 0.31.0

package/README.md

@@ -1,9 +1,7 @@
 
 # Welcome to Pinstripe
 
-## What is Pinstripe?
-
-Pinstripe is a slick [content management system (CMS)](https://en.wikipedia.org/wiki/Content_management_system) for Node.js.
+A slick web framework for Node.js.
 
 ## License
 

package/lib/apps/docs.js

@@ -0,0 +1,6 @@
+
+export default {
+    compose(){
+        return ['shared', 'docs'];
+    }
+};

package/lib/commands/list_apps.js

@@ -8,7 +8,7 @@ export default {
         console.log('The following apps are available:');
         console.log('');
         App.names.forEach(appName => {
-            console.log(`  * ${chalk.green(appName)} (composed of ${JSON.stringify(App.create(appName, this.context).compose())} views)`);
+            console.log(`  * ${chalk.green(appName)}`);
         });
         console.log('');
     }

package/lib/commands/list_views.js

@@ -6,31 +6,13 @@ export default {
     run(){
         const { extractOptions } = this.cliUtils;
 
-        const { app } = extractOptions();
+        const { app = 'main' } = extractOptions();
 
-        if(app){
-            this.listComposedViews(typeof app == 'string' ? app : 'main');
-        } else {
-            this.listAllViews();
-        }
-    },
-
-    listComposedViews(appName){
-        const { viewNames, resolveView } = View.mapperFor(App.create(appName, this.context).compose());
-        console.log('');
-        console.log(`The following views have been composed for app "${appName}":`);
-        console.log('');
-        viewNames.forEach(viewName => {
-            console.log(`  * ${chalk.green(viewName)} -> ${chalk.green(resolveView(viewName))}`);
-        });
-        console.log('');
-    },
-
-    listAllViews(){
+        const { viewNames } = View.mapperFor(App.create(app, this.context).compose());
         console.log('');
         console.log(`The following views are available:`);
         console.log('');
-        View.names.forEach(viewName => {
+        viewNames.forEach(viewName => {
             console.log(`  * ${chalk.green(viewName)}`);
         });
         console.log('');

package/lib/component.js

@@ -2,12 +2,13 @@
 import { fileURLToPath } from 'url'; // pinstripe-if-client: const fileURLToPath = undefined;
 
 import { Class } from './class.js';
-import { TEXT_ONLY_TAGS, IS_SERVER } from './constants.js';
+import { TEXT_ONLY_TAGS } from './constants.js';
 import { Inflector } from './inflector.js';
 import { VirtualNode } from './virtual_node.js';
 import { Registry } from './registry.js';
 import { ComponentEvent } from './component_event.js';
 import { Client } from './client.js'; // pinstripe-if-client: const Client = undefined;
+import { generateProofOfWork } from './proof_of_work.js';
 
 export const Component = Class.extend().include({
     meta(){
@@ -462,7 +463,10 @@ export const Component = Class.extend().include({
                 if(!(otherOptions.body instanceof FormData)) throw new Error(`Proof of work requires form data to be present`);
                 const values = {};
                 otherOptions.body.forEach((value, key) => values[key] = value);
-                otherOptions.body.append('_proofOfWork', await generateProofOfWork(values, abortController.signal))
+                otherOptions.body.append('_proofOfWork', await generateProofOfWork(values, { 
+                    abortSignal: abortController.signal,
+                    onProgress: progress => this.trigger('proofOfWorkProgress', { data: progress, bubbles: false })
+                }))
             }
             const promises = [
                 fetch(normalizedUrl, { signal: abortController.signal, ...otherOptions }), 
@@ -712,38 +716,4 @@ function normalizeVirtualNode(){
     }
 }
 
-async function generateProofOfWork(values, abortSignal){
-    const stringifiedValues = JSON.stringify(values);
-    const timestamp = getUTCTimestamp();
-    const random = btoa(`${Math.random()}`);
-    let counter = 0;
-    while(!abortSignal.aborted){
-        const candidateSolution = `1:20:${timestamp}:?::${random}:${btoa(`${counter}`)}`;
-        const hash = await createSha1Hash(candidateSolution.replace(/\?/, stringifiedValues));
-        if(hash.match(/^00000/)) return candidateSolution;
-        counter++;
-    }
-    return '';
-}
-
-function getUTCTimestamp() {
-    const now = new Date();
-  
-    const year = now.getUTCFullYear() % 100;
-    const month = String(now.getUTCMonth() + 1).padStart(2, '0');
-    const day = String(now.getUTCDate()).padStart(2, '0');
-    const hours = String(now.getUTCHours()).padStart(2, '0');
-    const minutes = String(now.getUTCMinutes()).padStart(2, '0');
-    const seconds = String(now.getUTCSeconds()).padStart(2, '0');
-  
-    return `${year}${month}${day}${hours}${minutes}${seconds}`;
-  }
-  
-
-async function createSha1Hash(input) {
-    const buffer = new TextEncoder().encode(input);
-    const hashArray = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-1', buffer)));
-    return hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
-}
-
 ComponentEvent.Component = Component;

package/lib/database/migrator.js

@@ -8,20 +8,20 @@ export const Migrator = Class.extend().include({
     },
 
     async migrate(){
-        if(!await this.database.table('pinstripeAppliedMigrations').exists){
-            await this.database.table('pinstripeAppliedMigrations', async pinstripeAppliedMigrations => {
-                await pinstripeAppliedMigrations.addColumn('schemaVersion', 'integer');
+        if(!await this.database.table('appliedMigrations').exists){
+            await this.database.table('appliedMigrations', async appliedMigrations => {
+                await appliedMigrations.addColumn('schemaVersion', 'integer');
             });
         }
         const isDevelopmentEnvironment = (process.env.NODE_ENV || 'development') == 'development';
         const migrations = Migration.names.map(name => Migration.for(name)).sort((a, b) => a.schemaVersion - b.schemaVersion);
         for(let i in migrations){
             const migration = migrations[i];
-            const isMigrationApplied = await this.database.table('pinstripeAppliedMigrations').where({ schemaVersion: migration.schemaVersion }).count() > 0;
+            const isMigrationApplied = await this.database.table('appliedMigrations').where({ schemaVersion: migration.schemaVersion }).count() > 0;
             if(!isMigrationApplied){
                 if(isDevelopmentEnvironment) console.log(`Applying migration: ${migration.name}`);
                 await migration.new(this.database).migrate();
-                await this.database.table('pinstripeAppliedMigrations').insert({ schemaVersion: migration.schemaVersion });
+                await this.database.table('appliedMigrations').insert({ schemaVersion: migration.schemaVersion });
             }
         }
     }

package/lib/extensions/_file_importer.js

@@ -0,0 +1 @@
+export default undefined;

package/lib/extensions/multi-tenant/database/row.js

@@ -0,0 +1,26 @@
+
+import { Table, Row } from 'pinstripe/database';
+
+Row.include({
+    meta(){
+        const { initialize, update } = this.prototype;
+
+        this.include({
+            initialize(database, fields, exists){
+                const columns = Table.for(this.constructor.collectionName).columns;
+                if(columns.tenantId && database.tenant){
+                    return initialize.call(this, database, { ...fields, tenantId: database.tenant.id }, exists);
+                }
+                return initialize.call(this, database, fields, exists);
+            },
+
+            update(fields){
+                const columns = Table.for(this.constructor.collectionName).columns;
+                if(columns.tenantId && this.database.tenant){
+                    return update.call(this, { ...fields, tenantId: this.database.tenant.id });
+                }
+                return update.call(this, fields);
+            }
+        });
+    }
+});

package/lib/extensions/multi-tenant/database/table.js

@@ -0,0 +1,30 @@
+
+import { Table } from 'pinstripe/database';
+
+Table.include({
+    meta(){
+        const { create, initialize } = this.prototype;
+
+        this.include({
+            async create(...args){
+                if(this.exists) return;
+                await create.call(this, ...args);
+                if(this.constructor.name == 'appliedMigrations') return;
+                if(this.constructor.name == 'tenants') return;
+                await this.addColumn('tenantId', 'foreign_key');
+            },
+            
+            initialize(...args){
+                const out = initialize.call(this, ...args);
+                if(this.constructor.columns.tenantId && this.database.scopedByTenant){
+                    if(this.database.tenant){
+                        this.where({ tenantId: this.database.tenant.id });
+                    } else {
+                        this.where('1 = 2')
+                    }
+                }
+                return out;
+            }
+        });
+    }
+});

package/lib/extensions/multi-tenant/database.js

@@ -0,0 +1,18 @@
+
+import { Database } from 'pinstripe';
+
+Database.include({
+    meta(){
+        const { singleton } = this.prototype;
+
+        this.include({
+            singleton(...args){
+                if(this.tenant) return singleton.call(this, ...args);
+            }
+        });
+    },
+
+    get scopedByTenant(){
+        return this.hasOwnProperty('tenant');
+    }
+});

package/lib/extensions/multi-tenant/index.js

@@ -0,0 +1,4 @@
+
+import { importAll } from 'pinstripe';
+
+importAll(import.meta.url);

package/lib/extensions/multi-tenant/migrations/1627976174_create_tenant_table_and_add_tenant_id_to_existing_tables.js

@@ -0,0 +1,20 @@
+
+export default {
+    async migrate(){
+        await this.database.table('tenants', async tenants => {
+            await tenants.addColumn('name', 'string', { index: true });
+            await tenants.addColumn('host', 'string', { index: true });
+        });  
+    
+        const tableNames = Object.keys(this.database.info).filter(name => this.database.info[name] == 'table');
+    
+        while(tableNames.length){
+            const tableName = tableNames.shift();
+            if(tableName == 'appliedMigrations') continue;
+            if(tableName == 'tenants') continue;
+            
+            if(this.database[tableName].constructor.columns.tenantId) continue;
+            await this.database[tableName].addColumn('tenantId', 'foreign_key');
+        }
+    }
+};

package/lib/extensions/multi-tenant/migrations/_file_importer.js

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

package/lib/extensions/multi-tenant/services/_file_importer.js

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

package/lib/extensions/multi-tenant/services/database.js

@@ -0,0 +1,32 @@
+
+import { Database } from 'pinstripe';
+import { Client } from "pinstripe/database";
+
+export default {
+    create(){
+        return this.defer(async () => {
+            if(!this.context.root.databaseClient){
+                this.context.root.databaseClient = Client.new(await this.config.database);
+            }
+
+            const out = await Database.new(this.context.root.databaseClient);
+
+            if(out.info.tenants){
+                const headers = this.initialParams._headers;
+                const hostname = this.initialParams._url.hostname;
+                const host = (headers['host'] || hostname).replace(/\:\d+$/, '').toLowerCase();
+                const { primaryDomain = '' } = await this.config;
+                const domainSuffix = `\.${primaryDomain}`.toLowerCase();
+
+                if(host.endsWith(domainSuffix)){
+                    const name = host.substr(0, host.length - domainSuffix.length);
+                    out.tenant = await out.tenants.where({ name }).first();
+                } else {
+                    out.tenant = await out.tenants.where({ host }).first();
+                }
+            }
+
+            return out;
+        });
+    }
+};

package/lib/markdown.js

@@ -39,7 +39,7 @@ export const Markdown = Class.extend().include({
             paragraph.attributes = {
                 ...paragraph.attributes,
                 'data-component': 'pinstripe-frame',
-                'data-url': `/markdown/slash_blocks/${name}?args=${encodeURIComponent(args)}`,
+                'data-url': `/_markdown_slash_blocks/${name}?args=${encodeURIComponent(args)}`,
             };
             paragraph.children = [];
         });

package/lib/proof_of_work.js

@@ -0,0 +1,93 @@
+
+import crypto from 'crypto' // pinstripe-if-client: const crypto = window.crypto;
+
+import { Class } from './class.js';
+import { Singleton } from './singleton.js';
+
+const HASH_CASH_TARGET = Math.pow(2, 32 - 20);
+
+export const ProofOfWork = Class.extend().include({
+    meta(){
+        this.include(Singleton)
+    },
+
+    async generateProofOfWork(input, options = {}){
+        const { difficulty = 1, steps = 1000, onProgress = () => {}, abortSignal = { aborted: false } } = options;
+        const inputHash = await this.createSha1Hash(JSON.stringify(input));
+        const salt = await this.createSha1Hash(Math.random());
+        const timestamp = this.getUTCTimestamp();
+        const target = this.calculateTarget(difficulty, steps);
+        const solution = [];
+        
+        let counter = -1;
+        for(let i = 1; i <= steps && !abortSignal.aborted; i++){
+            while(!abortSignal.aborted){
+                counter++;
+                const hash = await this.createSha1Hash(`${difficulty}:${steps}:${inputHash}:${salt}:${timestamp}:${counter}`);
+                const integers = this.hexToIntegers(hash);
+                if(integers[0] <= target) break;
+            }
+            solution.push(counter);
+            const progressPercentage = Math.floor(i * (100 / steps) * 100) / 100;
+            onProgress(progressPercentage);
+        }
+
+        if(abortSignal.aborted) return;
+
+        return JSON.stringify({
+            salt,
+            timestamp,
+            solution,
+        });
+    },
+
+    async verifyProofOfWork(input, proofOfWork, options = {}){
+        const { difficulty = 1 } = options;
+        const { salt, timestamp, solution } = JSON.parse(proofOfWork);
+        const steps = solution.length;
+        const inputHash = await this.createSha1Hash(JSON.stringify(input));
+        const target = this.calculateTarget(difficulty, steps);
+        for(let i = 0; i < steps; i++){
+            const counter = solution[i];
+            const hash = await this.createSha1Hash(`${difficulty}:${steps}:${inputHash}:${salt}:${timestamp}:${counter}`.toString(), true);
+            const integers = this.hexToIntegers(hash);
+            if(integers[0] > target) return false;
+        }
+        return true;
+    },
+
+    async createSha1Hash(input) {
+        const buffer = new TextEncoder().encode(input);
+        const hashArray = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-1', buffer)));
+        return hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+    },
+    
+    hexToIntegers(hex){
+        const out = [];
+        for(let i = 0; i < hex.length; i += 8){
+            out.push(parseInt(hex.slice(i, i + 8), 16));
+        }
+        return out;
+    },
+    
+    calculateTarget(difficulty, steps){
+        return (HASH_CASH_TARGET / difficulty) * steps;
+    },
+    
+    getUTCTimestamp() {
+        const now = new Date();
+      
+        const year = now.getUTCFullYear() % 100;
+        const month = String(now.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(now.getUTCDate()).padStart(2, '0');
+        const hours = String(now.getUTCHours()).padStart(2, '0');
+        const minutes = String(now.getUTCMinutes()).padStart(2, '0');
+        const seconds = String(now.getUTCSeconds()).padStart(2, '0');
+      
+        return `${year}${month}${day}${hours}${minutes}${seconds}`;
+    }
+});
+
+export const generateProofOfWork = (...args) => ProofOfWork.instance.generateProofOfWork(...args);
+  
+export const verifyProofOfWork = (...args) => ProofOfWork.instance.verifyProofOfWork(...args);

package/lib/services/cookies.js

@@ -3,7 +3,7 @@ export default {
     create(){
         if(!this.context.root.hasOwnProperty('cookies')){
             const cookies = {};
-            const cookieHeader = this.params._headers?.cookie;
+            const cookieHeader = this.initialParams._headers?.cookie;
             if(cookieHeader){
                 cookieHeader.split(/;/).forEach(cookie => {
                     const matches = cookie.trim().match(/^([^=]+)=(.*)$/);

package/lib/services/docs.js

@@ -0,0 +1,93 @@
+
+import { existsSync } from 'fs';
+import { realpath, readFile } from 'fs/promises';
+import { registries } from 'pinstripe/util';
+
+export default {
+    async create(){
+        if(!this.context.root.docs){
+            this.context.root.docs = {
+                apps: await this.extractDocs('App', 'apps'),
+                commands: await this.extractDocs('Command', 'commands'),
+                components: await this.extractDocs('Component', 'components'),
+                migrations: await this.extractDocs('Migration', 'migrations'),
+                models: await this.extractDocs('Row', 'models'),
+                services: await this.extractDocs('ServiceFactory', 'services'),
+                views: await this.extractDocs('View', 'views'),
+            };
+        }
+        return this.context.root.docs;
+    },
+
+
+
+    async extractDocs(name, namespace){
+        const out = {};
+        const registry = registries[name];
+        const { names } =  registry;
+        for(let name of names){
+            const slug = `${namespace}/${name}`;
+
+            const Class = registry.for(name);
+            
+            const filePath = Class.filePaths[Class.filePaths.length - 1];
+
+            if(!filePath || !filePath.match(/\.(js|css)/)) continue;
+
+            const packageRootPath = await this.getPackageRootPath(filePath);
+            
+            if(packageRootPath == undefined) continue;
+            
+            const packageJson = await this.getPackageJson(packageRootPath);
+
+            const packageName = packageJson.name;
+            
+            const packageRelativePath = filePath.substr(packageRootPath.length).replace(/^\//, '');
+            const repositoryRelativePath = `${packageJson.repository?.directory ? `${packageJson.repository.directory}/` : ''}${packageRelativePath}`;
+
+            const code = (await readFile(filePath)).toString('utf8');
+
+            const markdown = code.split(/\/\*\//).map((segment, i) => {
+                if(i % 2 == 0 && segment.trim().length){
+                    return `\`\`\`\n${segment}\n\`\`\``;
+                }
+                return segment;
+            }).join('');
+
+            out[name] = {
+                name,
+                slug,
+                packageName,
+                packageRelativePath,
+                repositoryRelativePath,
+                markdown
+            };
+        }
+        return out;
+    },
+
+    async getPackageRootPath(path){
+        const packageJsonPath = (await this.findInPath('package.json', path.replace(/[^/]*$/, ''))).shift();
+        if(!packageJsonPath) return;
+        return packageJsonPath.replace(/package.json$/, '');
+    },
+
+    async getPackageJson(packageRootPath){
+        return JSON.parse((await readFile(`${packageRootPath}package.json`)).toString('utf8'));
+    },
+
+    async findInPath(offset, base){
+        const out = [];
+        while(base) {
+            const candidatePath = `${base}/${offset}`;
+            if(existsSync(candidatePath)){
+                out.push(await realpath(candidatePath));
+            }
+            if(base == '/'){
+                break;
+            }
+            base = await realpath(`${base}/..`);
+        }
+        return out;
+    }
+};

package/lib/services/fetch.js

@@ -15,28 +15,18 @@ export default {
         const normalizedParams = this.normalizeParams(params);
         this.context.params = normalizedParams;
 
-        const viewName = normalizedParams._url.pathname.replace(/^\/|\/$/g, '');
+        const viewName = normalizedParams._url.pathname.replace(/^\/|\/$/g, '') || 'index';
         
         let out = await this.renderGuardViews(viewName, normalizedParams);
-        if(out){
-            return out;
-        }
+        if(out) return out;
 
-        if(!viewName.match(/(^|\/)_/)){
-            out = this.normalizeResponse(await this.renderView(viewName != '' ? `${viewName}/index`: 'index', normalizedParams));
-            if(out){
-                return out;
-            }
-            out = this.normalizeResponse(await this.renderView(viewName, normalizedParams));
-            if(out){
-                return out;
-            }
+        if(!viewName.match(/(^|\/)_[^\/]+(|\/index)$/)){
+            out = this.normalizeResponse(await this.app.renderView(viewName, normalizedParams));
+            if(out) return out;
         }
         
         out = await this.renderDefaultViews(viewName, normalizedParams);
-        if(out){
-            return out;
-        }
+        if(out) return out;
 
         return [404, {'content-type': 'text/plain'}, ['Not found']];
     },
@@ -44,22 +34,12 @@ export default {
     async renderGuardViews(viewName, params){
         const viewNameSegments = viewName != '' ? viewName.split(/\//) : [];
 
-        const candidateIndexView = [...viewNameSegments, 'index'].join('/');
-        const candidateDefaultView = [...viewNameSegments, 'default'].join('/');
-
-        if(!this.app.isView(candidateIndexView) && !this.app.isView(candidateDefaultView)){
-            viewNameSegments.pop();
-        }
-
         const prefixSegments = [];
         while(true){
-            const out = this.normalizeResponse(await this.renderView(prefixSegments.length ? [...prefixSegments, 'guard'].join('/') : 'guard', params));
-            if(out){
-                return out;
-            }
-            if(viewNameSegments.length == 0){
-                break;
-            }
+            const candidateGuardViewName = prefixSegments.length ? [...prefixSegments, 'guard'].join('/') : 'guard';
+            const out = this.normalizeResponse(await this.app.renderView(candidateGuardViewName, params));
+            if(out) return out;
+            if(viewNameSegments.length == 0) break;
             prefixSegments.push(viewNameSegments.shift());
         }
     },
@@ -67,28 +47,19 @@ export default {
     async renderDefaultViews(viewName, params){
         const prefixSegments = viewName != '' ? viewName.split(/\//) : [];
         while(true){
-            const out = this.normalizeResponse(await this.renderView(prefixSegments.length ? [...prefixSegments, 'default'].join('/') : 'default', params));
-            if(out){
-                return out;
-            }
-            if(prefixSegments.length == 0){
-                break;
-            }
+            const candidateDefaultViewName = prefixSegments.length ? [...prefixSegments, 'default'].join('/') : 'default';
+            const out = this.normalizeResponse(await this.app.renderView(candidateDefaultViewName, params));
+            if(out) return out;
+            if(prefixSegments.length == 0) break;
             prefixSegments.pop();
         }
     },
 
     normalizeParams(params){
         const out = { ...params }
-        if(!out._method){
-            out._method = 'get';
-        }
-        if(!params._url){
-            out._url = new URL('http://localhost')
-        }
-        if(!params._headers){
-            out._headers = {};
-        }
+        if(!out._method) out._method = 'get';
+        if(!params._url) out._url = new URL('http://localhost');
+        if(!params._headers) out._headers = {};
         return out;
     },
 
@@ -108,7 +79,7 @@ export default {
         const normalizedHeaders = {};
         Object.keys(headers).forEach(name => {
             normalizedHeaders[name.toLowerCase()] = headers[name];
-        })
+        });
 
         return [ status, normalizedHeaders, body ];
     }

package/lib/services/render_form.js

@@ -2,6 +2,7 @@ import * as crypto from 'crypto';
 
 import { ValidationError } from '../validation_error.js';
 import { Inflector } from '../inflector.js';
+import { verifyProofOfWork } from '../proof_of_work.js';
 
 export default {
     create(){
@@ -24,7 +25,7 @@ export default {
             try {
                 if(requiresProofOfWork){
                     if(!this.params._proofOfWork) throw new ValidationError({ _proofOfWork: 'Must not be blank' });
-                    if(!this.verifyProofOfWork(this.params._proofOfWork, values)) throw new ValidationError({ _proofOfWork: 'Must be a valid stamp' });
+                    if(!verifyProofOfWork(values, this.params._proofOfWork)) throw new ValidationError({ _proofOfWork: 'Must be a valid stamp' });
                 }
                 return await formAdapter.submit(values, success) || this.renderHtml`
                     <span data-component="pinstripe-anchor" data-target="_parent">
@@ -74,12 +75,6 @@ export default {
             submitTitle,
             cancelTitle
         });
-    },
-
-    verifyProofOfWork(proofOfWork, values){
-        const hash = crypto.createHash('sha1').update(proofOfWork.replace(/\?/, JSON.stringify(values)), 'binary').digest('hex');
-        if(hash.match(/^00000/)) return true;
-        return false;
     }
 }
 

package/lib/services/render_view.js

@@ -1,6 +1,6 @@
 
 export default {
     create(){
-        return (...args) => this.app.renderView(...args);
+        return (name, params = {}) => this.app.renderView(name, params);
     }
 };