pinstripe 0.34.0 → 0.36.0

package/README.md

@@ -1,7 +1,7 @@
 
 # Welcome to Pinstripe
 
-A slick web framework for your browser.
+A slick web framework for Node.js.
 
 ## License
 

package/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import 'haberdash/node';
+import chalk from 'chalk';
+
+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';
+import { ValidationError } from 'haberdash';
+import { inflector } from '@pinstripe/utils';
+
+(async () => {
+    const { entryPath, exists } = await Project.instance;
+    const { argv } = process;
+    const [name, ...args ] = argv.slice(2);
+
+    if(entryPath){
+        import(entryPath);
+    }
+
+    await importAll();
+
+    if(process.env.PINSTRIPE_KEEP_ALL_COMMANDS != 'true') {
+        if(exists){
+            Command.unregister('generate-project');
+            Command.unregister('initialize-project');
+        } else {
+            Command.names.forEach(commandName => {
+                if(commandName == 'list-commands' || commandName == 'generate-project') return;
+                Command.unregister(commandName);
+            });
+        }
+    }
+    
+    try {
+        await Workspace.run(async function(){
+            await this.runCommand(name, args);
+        });
+    } catch(error) {
+        if(error instanceof ValidationError) {
+            console.error('');
+            console.error('There was an error validating the command parameters:');
+            console.error('');
+            for(const [field, message] of Object.entries(error.errors)){
+                console.error(`  * ${chalk.red(`${inflector.dasherize(field)}: ${message}`)}`);
+            }
+            console.error('');
+            process.exit();
+        }
+        console.error(error);
+    }
+})();

package/lib/annotatable.js

@@ -0,0 +1 @@
+export * from 'haberdash/lib/annotatable.js';

package/lib/bundle.js

@@ -0,0 +1,95 @@
+
+import { build } from 'esbuild';
+import { promisify } from 'util';
+import { writeFile, readFile } from 'fs';
+import { dirSync } from 'tmp';
+import { fileURLToPath } from 'url';
+
+import { Class } from './class.js';
+import { AbstractImportableRegistry } from 'haberdash';
+import { Project } from './project.js';
+
+export const Bundle = Class.extend().include({
+    meta(){
+        this.include(AbstractImportableRegistry);
+
+        this.assignProps({
+            get modules(){
+                if(!this.hasOwnProperty('_modules')){
+                    this._modules = [];
+                }
+                return this._modules;
+            },
+
+            addModule(environment, module){
+                this.register(environment, {
+                    meta(){
+                        this.modules.push(module);
+                    }
+                });
+            },
+        });
+    },
+
+    async build(options = {}){
+        const { force = false } = options;
+        if(!this.constructor.buildPromise || force){
+            this.constructor.buildPromise = this._build();
+        }
+        return this.constructor.buildPromise;
+    },
+
+    async _build(){
+        const { name: tmpDir, removeCallback: deleteTmpDir } = dirSync({ unsafeCleanup: true });
+        const inFile = `${tmpDir}/in.js`;
+        const outFile = `${tmpDir}/out.js`;
+
+        await promisify(writeFile)(inFile, this.constructor.modules.map((_, i) => `import ${JSON.stringify(`${tmpDir}/module-${i}.js`)};`).join('\n'));
+
+        for(let i = 0; i < this.constructor.modules.length; i++){
+            await promisify(writeFile)(`${tmpDir}/module-${i}.js`, this.constructor.modules[i]);
+        }
+        
+        const { errors } = await build({
+            entryPoints: [inFile],
+            bundle: true,
+            sourcemap: true,
+            outfile: outFile,
+            plugins: [this.plugin],
+            nodePaths: await Project.instance.nodePaths,
+            minify: process.env.NODE_ENV == 'production',
+            logLevel: 'silent'
+        });
+
+        errors.forEach(error => console.error(error));
+
+        const out = {
+            js: (await promisify(readFile)(outFile, 'utf8')).replace(/\/\/#.*?$/m, ''),
+            map: await promisify(readFile)(`${outFile}.map`, 'utf8'),
+        };
+
+        await deleteTmpDir();
+
+        return out;
+    },
+
+    get plugin(){
+        return {
+            name: 'pinstripe',
+        
+            async setup(build){
+                build.onLoad({ filter: /\.js$/ }, async args => {
+                    const { path } = args;
+                    const contents = await promisify(readFile)(path, 'utf8');
+                    if(!contents.match(/pinstripe-if-client/)) return;
+                    const alteredContents = contents.replace(/(.*)\/\/\s*pinstripe-if-client:\s*(.*)/g, '$2 // pinstripe-if-server: $1');
+                    return { contents: alteredContents, loader: 'js' };
+                });
+            }
+        };
+    }
+});
+
+['window', 'serviceWorker'].forEach(environment => {
+    Bundle.addModule(environment, `import ${JSON.stringify(fileURLToPath(`${import.meta.url}/../index.js`))};`);
+});

package/lib/class.js

@@ -1,2 +1,2 @@
 
-export { Class } from '@sintra/utils';
+export { Class } from '@pinstripe/utils';

package/lib/command.js

@@ -0,0 +1,13 @@
+
+import { Class } from './class.js';
+import { AbstractCommand } from 'haberdash';
+import { ServiceFactory } from './service_factory.js';
+
+export const Command = Class.extend('Command').include({
+    meta(){
+        this.include(AbstractCommand);
+        this.include(ServiceFactory.Consumerable);
+    }
+});
+
+Command.binaryName = 'pinstripe';

package/lib/command.test.js

@@ -0,0 +1,70 @@
+import test from "node:test";
+import assert from "node:assert";
+
+import { Command } from "./command.js";
+
+test("Command validation through validate method", async () => {
+  const { Context } = await import("haberdash");
+  const { ValidationError } = await import("haberdash");
+
+  const TestCommand = Command.extend();
+  TestCommand.hasParam("name", { type: "string" });
+  TestCommand.hasParam("count", { type: "number", optional: true });
+
+  const context = Context.new();
+
+  context.params = { name: "test", count: 42 };
+  const command1 = TestCommand.new(context);
+  await assert.doesNotReject(async () => {
+    await command1.validate();
+  });
+
+  context.params = { name: "test", unknownParam: "value" };
+  const command2 = TestCommand.new(context);
+  await assert.rejects(
+    async () => {
+      await command2.validate();
+    },
+    ValidationError,
+    "Should throw ValidationError for unknown parameters"
+  );
+
+  context.params = { count: 42 };
+  const command3 = TestCommand.new(context);
+  await assert.rejects(
+    async () => {
+      await command3.validate();
+    },
+    ValidationError,
+    "Should throw ValidationError for missing required parameters"
+  );
+
+  context.params = { name: "test" };
+  const command4 = TestCommand.new(context);
+  await assert.doesNotReject(async () => {
+    await command4.validate();
+  });
+
+  context.params = { name: "test", badParam: "value" };
+  const command5 = TestCommand.new(context);
+  try {
+    await command5.validate();
+    assert.fail("Expected validation to throw");
+  } catch (error) {
+    assert(error instanceof ValidationError, "Should be ValidationError");
+    assert(error.errors, "Should have errors property");
+    assert(error.errors.badParam, "Should have badParam error");
+    assert(
+      error.errors.badParam.includes("Unknown parameter"),
+      `Expected error message to contain "Unknown parameter", but got: ${error.errors.badParam}`
+    );
+  }
+});
+
+test("Pinstripe Command has binaryName 'pinstripe'", () => {
+  assert.equal(Command.binaryName, "pinstripe");
+});
+
+test("Pinstripe Command has list-commands registered", () => {
+  assert(Command.names.includes("list-commands"), "list-commands should be registered");
+});

package/lib/commands/_file_importer.js

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

package/lib/commands/generate_command.js

@@ -0,0 +1,42 @@
+
+
+export default {
+    meta(){
+        this.assignProps({
+            description: 'Generates a new command file in the lib/commands directory.'
+        });
+        
+        this.hasParam('name', { type: 'string', alias: 'arg1', description: 'The name of the command to create (in snake_case).' });
+    },
+
+    async run(){
+        const normalizedName = this.inflector.snakeify(this.params.name);
+
+        const { inProjectRootDir, generateFile } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/commands/_file_importer.js`, { skipIfExists: true }, ({ line }) => {
+                line();
+                line(`export { Command as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/commands/${normalizedName}.js`, ({ line, indent }) => {
+                line();
+                line(`export default {`);
+                indent(({ line, indent }) => {
+                    line('run(){');
+                    indent(({ line }) => {
+                        line(`console.log('${this.inflector.dasherize(normalizedName)} command coming soon!')`);
+                    });
+                    line('}');
+                });
+                line('};');
+                line();
+            });
+    
+        });
+    }
+}
+

package/lib/commands/generate_job.js

@@ -0,0 +1,50 @@
+
+
+export default {
+    meta(){
+        this.assignProps({
+            description: 'Generates a new job file in the lib/jobs directory.'
+        });
+
+        this.hasParam('name', { type: 'string', alias: 'arg1', description: 'The name of the job to create (in snake_case).' });
+    },
+
+    async run(){
+        const normalizedName = this.inflector.snakeify(this.params.name);
+
+        const { inProjectRootDir, generateFile } = this.fsBuilder;
+
+        await inProjectRootDir(async () => {
+
+            await generateFile(`lib/jobs/_file_importer.js`, { skipIfExists: true }, ({ line }) => {
+                line();
+                line(`export { Job as default } from 'pinstripe';`);
+                line();
+            });
+
+            await generateFile(`lib/jobs/${normalizedName}.js`, ({ line, indent }) => {
+                line();
+                line(`export default {`);
+                indent(({ line, indent }) => {
+                    line('meta(){');
+                    indent(({ line }) => {
+                        line(`this.schedule('* * * * *'); // run every minute`);
+                    });
+                    line('},');
+                });
+                line();
+                indent(({ line, indent }) => {
+                    line('run(){');
+                    indent(({ line }) => {
+                        line(`console.log('${this.inflector.dasherize(normalizedName)} job coming soon!')`);
+                    });
+                    line('}');
+                });
+                line('};');
+                line();
+            });
+
+        });
+    }
+}
+

package/lib/commands/generate_project.js

@@ -0,0 +1,178 @@
+
+import { spawnSync } from 'child_process';
+import * as crypto from 'crypto';
+
+export default {
+   meta(){
+      this.assignProps({
+         description: 'Generates a new Pinstripe project with the specified dependencies and configuration.'
+      });
+      
+      this.hasParam('name', { type: 'string', alias: 'arg1', description: 'The name of the project to create.' });
+      this.hasParam('with', { type: 'string', optional: true, description: 'Additional dependencies to include (space-separated).' });
+   },
+
+   async run(){
+      const name = this.params.name;
+      const { with: _with = '' } = this.params;
+
+      const dependencies = ['pinstripe'];
+      _with.split(/\s+/).map(dependency => dependency.trim()).filter(Boolean).forEach(dependency => {
+         if(!dependencies.includes(dependency)) dependencies.push(dependency);
+      });
+
+      Object.assign(this, { name, dependencies });
+   
+      const { generateDir } = this.fsBuilder;
+   
+      await generateDir(name, async () => {
+         await this.generatePackageJson();
+
+         await this.generatePinstripeConfig();
+   
+         await this.generateLibIndex();
+      
+         await this.generateReadme();
+
+         this.installDependencies();
+
+         await this.initializeProject();
+      });
+   },
+
+   async generatePackageJson(){
+      const { generateFile } = this.fsBuilder;
+
+      await generateFile(`package.json`, ({ echo }) => {
+         echo(JSON.stringify({
+            type: "module",
+            name: this.name,
+            version: "0.0.0",
+            license: "MIT",
+            exports: {
+               ".": "./lib/index.js"
+            },
+         }, null, 2));
+      });
+   },
+
+   async generatePinstripeConfig(){
+      const { generateFile } = this.fsBuilder;
+
+      await generateFile(`pinstripe.config.js`, ({ line, indent }) => {
+         line();
+         line(`const environment = process.env.NODE_ENV || 'development';`);
+         line();
+         line(`let database;`);
+         line(`if(environment == 'production'){`)
+         indent(({ line, indent }) => {
+            line(`database = {`);
+            indent(({ line }) => {
+               line(`adapter: 'mysql',`)
+               line(`host: 'localhost',`);
+               line(`user: 'root',`);
+               line(`password: '',`);
+               line(`database: \`${this.inflector.snakeify(this.name)}_\${environment}\``);
+            });
+            line(`};`);
+         });
+         line(`} else {`);
+         indent(({ line, indent }) => {
+            line(`database = {`);
+            indent(({ line }) => {
+               line(`adapter: 'sqlite',`);
+               line(`filename: \`\${environment}.db\``)
+            });
+            line(`};`);
+         });
+         line(`}`);
+         line();
+         line(`let mail;`);
+         line(`if(environment == 'production'){`)
+         indent(({ line, indent }) => {
+            line(`mail = {`);
+            indent(({ line, indent }) => {
+               line(`adapter: 'smtp',`)
+               line(`host: "smtp.example.com",`)
+               line(`port: 465,`);
+               line(`secure: true, // use TLS`);
+               line(`auth: {`);
+               indent(({ line }) => {
+                  line(`user: "username",`);
+                  line(`pass: "password",`);
+               });
+               line(`}`);
+            });
+            line(`};`);
+         });
+         line(`} else {`);
+         indent(({ line, indent }) => {
+            line(`mail = {`);
+            indent(({ line }) => {
+               line(`adapter: 'dummy'`);
+            });
+            line(`};`);
+         });
+         line(`}`);
+         line();
+         line(`export default {`);
+         indent(({ line }) => {
+            line(`database,`);
+            line(`mail,`);
+            line(`salt: '${crypto.randomUUID()}'`)
+         })
+         line(`};`);
+      });
+   },
+
+   async generateLibIndex(){
+      const { generateFile } = this.fsBuilder;
+
+      await generateFile(`lib/index.js`, ({ line }) => {
+         line();
+         this.dependencies.forEach((dependency) => {
+            if(dependency != 'pinstripe') line(`import '${dependency}';`);
+         });
+         line();
+         line(`import { importAll } from 'pinstripe';`);
+         line();
+         line(`importAll(import.meta.url);`);
+         line();
+      });
+   },
+
+   async generateReadme(){
+      const { generateFile } = this.fsBuilder;
+
+      await generateFile(`README.md`, ({ line, indent }) => {
+         line();
+         line(`# ${this.name}`);
+         line();
+         line('## Getting started');
+         line();
+         line('```bash');
+         indent(({ line }) => {
+            line('pinstripe initialize-database');
+            line('pinstripe start-server');
+         });
+         line('```');
+         line();
+      });
+   },
+
+   installDependencies(){
+      spawnSync('npm', [ 'install', ...this.dependencies ], {
+         stdio: 'inherit'
+      });
+   },
+
+   initializeProject(){
+      spawnSync('npx', [ 'pinstripe', 'initialize-project'], {
+         stdio: 'inherit',
+         env: {
+            ...process.env,
+            PINSTRIPE_KEEP_ALL_COMMANDS: 'true',
+         }
+      });
+   }
+};

package/lib/commands/generate_service.js

@@ -0,0 +1,38 @@
+
+export default {
+    meta(){
+        this.assignProps({
+            description: 'Generates a new service file in the lib/services directory.'
+        });
+        
+        this.hasParam('name', { type: 'string', alias: 'arg1', description: 'The name of the service to create (in snake_case).' });
+    },
+
+    async run(){
+        const name = this.params.name;
+    
+        const { inProjectRootDir, generateFile } = this.fsBuilder;
+    
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/services/_file_importer.js`, { skipIfExists: true }, ({ line }) => {
+                line();
+                line(`export { ServiceFactory as default } from 'pinstripe';`);
+                line();
+            });
+    
+            await generateFile(`lib/services/${this.inflector.snakeify(name)}.js`, ({ line, indent }) => {
+                line(`export default {`);
+                indent(({ line, indent }) => {
+                    line('create(){');
+                    indent(({ line }) => {
+                        line(`return 'Example ${this.inflector.camelize(name)} service'`);
+                    });
+                    line('}');
+                });
+                line('};');
+            });
+    
+        });
+    }
+};

package/lib/commands/generate_view.js

@@ -0,0 +1,83 @@
+
+import { View } from 'pinstripe';
+import { readFile } from 'fs/promises';
+
+export default {
+    meta(){
+        this.assignProps({
+            description: 'Generates a new view file in the lib/views directory.'
+        });
+
+        this.hasParam('name', { type: 'string', description: 'The name of the view to create (has a .js file extension by default).' });
+    },
+
+    async run(){
+        let normalizedName = this.params.name.replace(/^\//, '');
+
+        const existingFilePaths = [ ...View.for(normalizedName).filePaths ];
+        const existingFilePath = existingFilePaths.pop();
+        const existingFileExtension = (existingFilePath ? existingFilePath.match(/^.*\.([^\/]+)$/) : [])[1];
+        if(!normalizedName.match(/\.[^\/]+$/)){
+            if(existingFileExtension) {
+                normalizedName = `${normalizedName}.${existingFileExtension}`;
+            } else {
+                normalizedName = `${normalizedName}.js`;
+            }
+        }
+
+        const normalizedNameExtension = normalizedName.match(/^.*\.([^\/]+)$/)[1];
+
+        const useExistingFile = normalizedNameExtension == existingFileExtension;
+    
+        const existingFileData = useExistingFile ? (await readFile(existingFilePath)).toString('utf8') : '';
+
+        const { inProjectRootDir, generateFile } = this.fsBuilder;
+
+        await inProjectRootDir(async () => {
+    
+            await generateFile(`lib/views/_file_importer.js`, { skipIfExists: true }, ({ line }) => {
+                line();
+                line(`export { View as default } from 'pinstripe';`);
+                line();
+            });
+
+            await generateFile(`lib/views/${normalizedName}`, ({ echo, line, indent }) => {
+                if(useExistingFile){
+                    echo(existingFileData);
+                } else if(normalizedNameExtension == 'js') {
+                    line();
+                    line('export const styles = `');
+                    indent(({ line, indent }) => {
+                        line(".root {");
+                        indent(({ line }) => {
+                            line("background: yellow;");
+                        });
+                        line("}");
+                    });
+                    line('`;');
+                    line();
+                    line('export default {');
+                    indent(({ line, indent }) => {
+                        line('render(){')
+                        indent(({ line, indent }) => {
+                            line('return this.renderHtml`')
+                            indent(({ line, indent }) => {
+                                line('<div class="${this.cssClasses.root}">');
+                                indent(({ line }) => {
+                                    line(`<h1>${normalizedName} view</h1>`);
+                                });
+                                line(`</div>`)
+                            });
+                            line('`;');
+                        });
+                        line('}');
+                    });
+                    line('};');
+                    line();
+                } else {
+                    line();
+                }
+            });
+        });
+    }
+};

package/lib/commands/initialize_project.js

@@ -0,0 +1,6 @@
+
+export default {
+    async run(){
+        await this.runHook('run');
+    }
+};

package/lib/commands/list_jobs.js

@@ -0,0 +1,21 @@
+
+import chalk from 'chalk';
+import { Job } from 'pinstripe';
+
+export default {
+    meta(){
+        this.assignProps({
+            description: 'Lists all available jobs in the current project.'
+        });
+    },
+
+    run(){
+        console.log('');
+        console.log('The following jobs are available:');
+        console.log('');
+        Job.names.forEach(jobName => {
+            console.log(`  * ${chalk.green(jobName)}`);
+        });
+        console.log('');
+    }
+};