pinstripe 0.30.0 → 0.31.1

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/commands/purge_used_hashes.js

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

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/migrations/1708772281_create_used_hash.js

@@ -0,0 +1,9 @@
+
+export default {
+    async migrate(){
+        await this.database.table('usedHashes', async usedHashes => {
+            await usedHashes.addColumn('value', 'string', { index: true });
+            await usedHashes.addColumn('expiresAt', 'datetime', { index: true });
+        });
+    }
+};

package/lib/migrations/_file_importer.js

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

package/lib/models/_file_importer.js

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

package/lib/models/used_hash.js

@@ -0,0 +1,7 @@
+
+export default {
+    meta(){
+        this.mustNotBeBlank('value');
+        this.mustNotBeBlank('expiresAt');
+    }
+};

package/lib/proof_of_work.js

@@ -0,0 +1,84 @@
+
+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);
+const DEFAULT_DIFFICULTY = 1 / 20;
+const DEFAULT_EXPIRY_IN_SECONDS = 10 * 60;
+
+export const ProofOfWork = Class.extend().include({
+    meta(){
+        this.include(Singleton)
+    },
+
+    async generateProofOfWork(input, options = {}){
+        const { difficulty = DEFAULT_DIFFICULTY, steps = 1000, onProgress = () => {}, abortSignal = { aborted: false } } = options;
+        const inputHash = await this.createSha1Hash(JSON.stringify(input));
+        const salt = await this.createSha1Hash(Math.random());
+        const timestamp = Math.floor(Date.now() / 1000);
+        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 = DEFAULT_DIFFICULTY, expiryInSeconds = DEFAULT_EXPIRY_IN_SECONDS } = options;
+        const { salt, timestamp, solution } = JSON.parse(proofOfWork);
+        if(Math.floor(Date.now() / 1000) - timestamp > expiryInSeconds) return false;
+        const steps = solution.length;
+        if(typeof steps !== 'number' || steps <= 0) return false;
+        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;
+    }
+});
+
+export const generateProofOfWork = (...args) => ProofOfWork.instance.generateProofOfWork(...args);
+  
+export const verifyProofOfWork = (...args) => ProofOfWork.instance.verifyProofOfWork(...args);

package/lib/services/fetch.js

@@ -15,29 +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(/(^|\/)_[^\/]+(|\/index)$/)){
-            out = this.normalizeResponse(await this.app.renderView(viewName != '' ? `${viewName}/index`: 'index', normalizedParams));
-            if(out){
-                return out;
-            }
-        
             out = this.normalizeResponse(await this.app.renderView(viewName, normalizedParams));
-            if(out){
-                return out;
-            }
+            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']];
     },
@@ -45,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.app.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());
         }
     },
@@ -68,28 +47,19 @@ export default {
     async renderDefaultViews(viewName, params){
         const prefixSegments = viewName != '' ? viewName.split(/\//) : [];
         while(true){
-            const out = this.normalizeResponse(await this.app.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;
     },
 
@@ -109,7 +79,7 @@ export default {
         const normalizedHeaders = {};
         Object.keys(headers).forEach(name => {
             normalizedHeaders[name.toLowerCase()] = headers[name];
-        })
+        });
 
         return [ status, normalizedHeaders, body ];
     }

package/lib/services/only_once.js

@@ -0,0 +1,24 @@
+
+import crypto from 'crypto';
+
+export default {
+    create(){
+        return this;
+    },
+
+    async hasBeenUsed(key){
+        return await this.database.withoutTenantScope.usedHashes.where({value: this.createHash(key)}).count() > 0;
+    },
+
+    async markAsUsed(key, options = {}){
+        const { expiresAt = new Date(Date.now() + (1000 * 60 * 60 * 24)) } = options;
+        await this.database.usedHashes.insert({
+            value: this.createHash(key),
+            expiresAt
+        });
+    },
+
+    createHash(key){
+        return crypto.createHash('sha1').update(JSON.stringify(key)).digest('base64');
+    }
+};

package/lib/services/render_form.js

@@ -1,7 +1,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,13 +24,16 @@ 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(!await verifyProofOfWork(values, this.params._proofOfWork)) throw new ValidationError({ _proofOfWork: 'Must be a valid' });
+                    if(await this.onlyOnce.hasBeenUsed({ proofOfWork: this.params._proofOfWork })) throw new ValidationError({ _proofOfWork: 'Must be unused' });
                 }
-                return await formAdapter.submit(values, success) || this.renderHtml`
+                const out = await formAdapter.submit(values, success) || this.renderHtml`
                     <span data-component="pinstripe-anchor" data-target="_parent">
                         <script type="pinstripe">this.parent.trigger('click');</script>
                     </span>
                 `;
+                if(requiresProofOfWork) await this.onlyOnce.markAsUsed({ proofOfWork: this.params._proofOfWork });
+                return out;
             } catch(e){
                 if(!(e instanceof ValidationError)){
                     throw e;
@@ -74,12 +77,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,12 +1,6 @@
 
 export default {
     create(){
-        return async (name, params = {}) => {
-            const out = await this.app.renderView(name != '' ? `${name}/index`: 'index', params);
-            if(out){
-                return out;
-            }
-            return this.app.renderView(name, params);
-        }
+        return (name, params = {}) => this.app.renderView(name, params);
     }
 };

package/lib/view.js

@@ -35,6 +35,7 @@ export const View = Class.extend().include({
                 if(!this.cache.mappers) this.cache.mappers = {};
                 if(!this.cache.mappers[cacheKey]){
                     const map = {};
+
                     namespaces.forEach(namespace => {
                         this.names.forEach(name => {
                             const pattern = new RegExp(`^${namespace}/(.*)$`);
@@ -43,6 +44,11 @@ export const View = Class.extend().include({
                             map[matches[1]] = name;
                         })
                     });
+
+                    Object.keys(map).forEach(name => {
+                        const matches = name.match(/^(.*)\/index$/);
+                        if(matches && !map[matches[1]]) map[matches[1]] = map[name];
+                    });
                     
                     this.cache.mappers[cacheKey] = Class.extend().include({
                         isView(name){

package/lib/views/shared/_form.js

@@ -91,35 +91,25 @@ export const styles = `
         font-size: 12px;
     }
 
-    @keyframes form-spinner {
-        to {transform: rotate(360deg);}
-    }
-
-    .spinner {
-        position: relative;
+    .proof-of-work-progress {
         display: inline-block;
-        width: 1em;
-        height: 1em;
-        margin-right: 1em;
-    }
-       
-    .spinner:before {
-        content: '';
-        box-sizing: border-box;
-        position: absolute;
-        top: 50%;
-        left: 50%;
-        width: 1em;
-        height: 1em;
-        margin-top: -0.5em;
-        margin-left: -0.5em;
-        border-radius: 50%;
-        border: 2px solid #ccc;
-        border-top-color: #000;
-        animation: form-spinner .6s linear infinite;
+        margin-left: 0.5em;
     }
 `;
 
+export const decorators = {
+    proofOfWorkProgress(){
+        this.frame.on('proofOfWorkProgress', e => {
+            const progress = e.detail;
+            this.patch({
+                ...this.attributes,
+                value: progress
+            });
+            this.patch(`${progress} %`);
+        });
+    }
+};
+
 export default {
     render(){
         const {
@@ -224,8 +214,7 @@ export default {
                                 ${() => {
                                     if(isPlaceholder && requiresProofOfWork) return this.renderHtml`
                                         <span class="${this.cssClasses.loadingIndicator}">
-                                            <span class="${this.cssClasses.spinner}"></span>
-                                            Generating anti-spam code - please be patient...
+                                            Generating anti-spam code <progress class="${this.cssClasses.proofOfWorkProgress}" max="100">0.0 %</progress>
                                         </span>
                                     `;
                                 }}

package/package.json

@@ -2,7 +2,7 @@
   "type": "module",
   "name": "pinstripe",
   "description": "A slick web framework for Node.js.",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "author": "Jody Salt",
   "license": "MIT",
   "exports": {
@@ -53,5 +53,5 @@
     "url": "git://github.com/blognami/pinstripe.git",
     "directory": "packages/pinstripe"
   },
-  "gitHead": "07d0e77a033fd16381b2641ad22158dc1857899e"
+  "gitHead": "73c659004059facb56e4f96e32d2d443e989d348"
 }