ts-prorm-orm 1.1.0 → 1.2.1

package/dist/cli/commands/scaffold.js

@@ -0,0 +1,383 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// Scaffold command module for the prorm CLI. Generates local project files —
+// new projects, models, migrations, seeders, and connection blocks — directly
+// on the filesystem. These commands never touch the cloud/dashboard API; they
+// only read and write files in the current working tree via Node fs/path.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const framework_1 = require("../framework");
+const DIALECTS = ['sqlite', 'postgres', 'mysql', 'mariadb'];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Capitalize the first letter, e.g. "user" -> "User". */
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/** Compact UTC timestamp for migration/seeder filenames, e.g. 20260707T120000. */
+function timestamp() {
+    return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, '').replace('T', 'T');
+}
+/** Slugify an arbitrary name into a filename-safe token. */
+function slug(name) {
+    return name
+        .trim()
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/** Write a file, creating parent directories as needed. */
+function writeFile(filePath, contents) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, contents, 'utf8');
+}
+/** Build a default connection block for a dialect. */
+function defaultConnection(dialect, name = 'app') {
+    if (dialect === 'sqlite') {
+        return { dialect, storage: `./${name}.sqlite` };
+    }
+    const port = dialect === 'postgres' ? 5432 : 3306;
+    return {
+        dialect,
+        host: 'localhost',
+        port,
+        database: name,
+        username: dialect === 'postgres' ? 'postgres' : 'root',
+        password: '',
+    };
+}
+/** Build the DATABASE_URL / storage line for an .env file. */
+function envLine(dialect, name) {
+    switch (dialect) {
+        case 'sqlite':
+            return `# SQLite stores data in a local file.\nDATABASE_STORAGE=./${name}.sqlite`;
+        case 'postgres':
+            return `DATABASE_URL=postgres://postgres:password@localhost:5432/${name}`;
+        case 'mysql':
+            return `DATABASE_URL=mysql://root:password@localhost:3306/${name}`;
+        case 'mariadb':
+            return `DATABASE_URL=mariadb://root:password@localhost:3306/${name}`;
+    }
+}
+// ─── Templates ────────────────────────────────────────────────────────────────
+function packageJsonTemplate(name) {
+    return (JSON.stringify({
+        name: slug(name) || name,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            build: 'tsc',
+            migrate: 'prorm migrate',
+            seed: 'prorm seed',
+            start: 'node dist/index.js',
+        },
+        dependencies: {
+            'ts-prorm-orm': '^1.0.0',
+        },
+        devDependencies: {
+            prorm: '^1.0.0',
+            typescript: '^5.4.0',
+        },
+    }, null, 2) + '\n');
+}
+function configTemplate(dialect, name) {
+    const config = {
+        dialect,
+        connection: defaultConnection(dialect, name),
+    };
+    return JSON.stringify(config, null, 2) + '\n';
+}
+function modelTemplate(Name) {
+    return `import { Prorm, DataTypes } from 'ts-prorm-orm';
+
+// The ${Name} model. Fields are declared with DataTypes; Prorm.define wires the
+// model to the active connection resolved from prorm.config.json.
+export const ${Name} = Prorm.define('${Name}', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+  },
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true,
+  },
+  createdAt: {
+    type: DataTypes.DATE,
+    defaultValue: DataTypes.NOW,
+  },
+});
+
+export type ${Name}Attributes = {
+  id: number;
+  name: string;
+  email: string;
+  createdAt: Date;
+};
+
+// Example:
+//   const row = await ${Name}.create({ name: 'Ada', email: 'ada@example.com' });
+//   const all = await ${Name}.findAll();
+export default ${Name};
+`;
+}
+function envExampleTemplate(dialect, name) {
+    return `# Environment configuration for ${name}.
+# Copy this file to .env and fill in real credentials.
+${envLine(dialect, name)}
+`;
+}
+function readmeTemplate(name, dialect) {
+    return `# ${name}
+
+A prorm project scaffolded with the prorm CLI (dialect: **${dialect}**).
+
+## Getting started
+
+\`\`\`sh
+npm install
+cp .env.example .env   # then edit credentials
+npm run migrate        # apply migrations
+npm start
+\`\`\`
+
+## Layout
+
+- \`prorm.config.json\` — connection + dialect configuration.
+- \`src/models/\` — prorm model definitions.
+- \`migrations/\` — schema migrations (see \`prorm add migration --name <name>\`).
+- \`seeders/\` — data seeders (see \`prorm add seeder --name <name>\`).
+
+## Adding resources
+
+\`\`\`sh
+prorm add model --name Post
+prorm add migration --name create-posts
+prorm add seeder --name demo-users
+prorm add connection --dialect postgres
+\`\`\`
+`;
+}
+function migrationTemplate(name) {
+    return `import type { Prorm } from 'ts-prorm-orm';
+
+// Migration: ${name}
+// Runs inside a transaction. Implement the forward change in up() and the
+// inverse in down() so the migration is reversible.
+export async function up(prorm: Prorm): Promise<void> {
+  await prorm.schema.createTable('examples', (table) => {
+    table.increments('id').primaryKey();
+    table.string('title').notNullable();
+    table.timestamps();
+  });
+}
+
+export async function down(prorm: Prorm): Promise<void> {
+  await prorm.schema.dropTable('examples');
+}
+`;
+}
+function seederTemplate(name) {
+    return `import type { Prorm } from 'ts-prorm-orm';
+
+// Seeder: ${name}
+// Inserts baseline/demo data. Keep seeders idempotent where possible.
+export async function seed(prorm: Prorm): Promise<void> {
+  await prorm.table('examples').insert([
+    { title: 'First example' },
+    { title: 'Second example' },
+  ]);
+}
+`;
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
+const newProject = (0, framework_1.defineCommand)({
+    name: 'new',
+    description: 'Scaffold a new prorm project directory with starter files.',
+    group: 'Scaffold',
+    positionals: [{ name: 'name', description: 'Project name.', required: true }],
+    flags: [
+        {
+            name: 'dialect',
+            type: 'string',
+            description: 'Database dialect.',
+            choices: DIALECTS,
+            default: 'sqlite',
+        },
+        { name: 'dir', type: 'string', description: 'Target directory (defaults to the project name).' },
+        { name: 'force', type: 'boolean', description: 'Overwrite an existing directory.' },
+    ],
+    examples: [
+        'orm-cli new blog',
+        'orm-cli new blog --dialect postgres',
+        'orm-cli new blog --dir ./apps/blog --force',
+    ],
+    run: (ctx) => {
+        const name = ctx.positionals[0];
+        if (!name) {
+            framework_1.out.error('A project <name> is required.');
+            return 1;
+        }
+        const dialect = ctx.flags.dialect;
+        const dir = ctx.flags.dir || name;
+        const force = ctx.flags.force === true;
+        const target = path.resolve(process.cwd(), dir);
+        if (fs.existsSync(target)) {
+            if (!force) {
+                framework_1.out.error(`Directory already exists: ${target} (use --force to overwrite).`);
+                return 1;
+            }
+            framework_1.out.warn(`Overwriting existing directory: ${target}`);
+        }
+        fs.mkdirSync(target, { recursive: true });
+        const files = [
+            ['package.json', packageJsonTemplate(name)],
+            ['prorm.config.json', configTemplate(dialect, slug(name) || name)],
+            [path.join('src', 'models', 'User.ts'), modelTemplate('User')],
+            ['.env.example', envExampleTemplate(dialect, slug(name) || name)],
+            ['README.md', readmeTemplate(name, dialect)],
+        ];
+        for (const [rel, contents] of files) {
+            writeFile(path.join(target, rel), contents);
+            framework_1.out.dim(`  created ${path.join(dir, rel)}`);
+        }
+        framework_1.out.success(`Scaffolded ${name}`);
+        framework_1.out.info('');
+        framework_1.out.info('Next steps:');
+        framework_1.out.info(`  cd ${dir}`);
+        framework_1.out.info('  npm install');
+        framework_1.out.info('  cp .env.example .env');
+        return 0;
+    },
+});
+const add = (0, framework_1.defineCommand)({
+    name: 'add',
+    description: 'Add a local resource: model, migration, seeder, or connection.',
+    group: 'Scaffold',
+    positionals: [
+        {
+            name: 'resource',
+            description: 'What to add.',
+            required: true,
+            choices: ['model', 'migration', 'seeder', 'connection'],
+        },
+    ],
+    flags: [
+        { name: 'name', type: 'string', description: 'Name (required for model/migration/seeder).' },
+        {
+            name: 'dialect',
+            type: 'string',
+            description: 'Dialect for a new connection.',
+            choices: DIALECTS,
+            default: 'sqlite',
+        },
+    ],
+    examples: [
+        'orm-cli add model --name Post',
+        'orm-cli add migration --name create-posts',
+        'orm-cli add seeder --name demo-users',
+        'orm-cli add connection --dialect postgres',
+    ],
+    run: (ctx) => {
+        const resource = ctx.positionals[0];
+        if (!resource) {
+            framework_1.out.error('A <resource> is required (model, migration, seeder, or connection).');
+            return 1;
+        }
+        const rawName = ctx.flags.name;
+        const cwd = process.cwd();
+        if (resource === 'model') {
+            if (!rawName) {
+                framework_1.out.error('--name is required for a model.');
+                return 1;
+            }
+            const Name = capitalize(rawName);
+            const filePath = path.join(cwd, 'src', 'models', `${Name}.ts`);
+            writeFile(filePath, modelTemplate(Name));
+            framework_1.out.success(`Created model ${path.relative(cwd, filePath)}`);
+            return 0;
+        }
+        if (resource === 'migration') {
+            if (!rawName) {
+                framework_1.out.error('--name is required for a migration.');
+                return 1;
+            }
+            const filePath = path.join(cwd, 'migrations', `${timestamp()}-${slug(rawName)}.ts`);
+            writeFile(filePath, migrationTemplate(rawName));
+            framework_1.out.success(`Created migration ${path.relative(cwd, filePath)}`);
+            return 0;
+        }
+        if (resource === 'seeder') {
+            if (!rawName) {
+                framework_1.out.error('--name is required for a seeder.');
+                return 1;
+            }
+            const filePath = path.join(cwd, 'seeders', `${timestamp()}-${slug(rawName)}.ts`);
+            writeFile(filePath, seederTemplate(rawName));
+            framework_1.out.success(`Created seeder ${path.relative(cwd, filePath)}`);
+            return 0;
+        }
+        // resource === 'connection'
+        const dialect = ctx.flags.dialect;
+        const connName = rawName ? slug(rawName) : dialect;
+        const configPath = path.join(cwd, 'prorm.config.json');
+        let config;
+        if (fs.existsSync(configPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            }
+            catch {
+                framework_1.out.error(`Could not parse existing ${path.relative(cwd, configPath)} (invalid JSON).`);
+                return 1;
+            }
+        }
+        else {
+            config = { dialect, connection: defaultConnection(dialect) };
+        }
+        config.connections = config.connections ?? {};
+        config.connections[connName] = defaultConnection(dialect, connName);
+        writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+        framework_1.out.success(`Added connection "${connName}" (${dialect}) to ${path.relative(cwd, configPath)}`);
+        return 0;
+    },
+});
+exports.commands = [newProject, add];

package/dist/cli/commands/secrets.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];

package/dist/cli/commands/secrets.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// Secrets command module for the prorm CLI. Manages secrets held in the AWS
+// Secrets Manager vault, brokered by the dashboard API. Secrets may be scoped to
+// a team via --team (defaulting to the selected team) or left at personal scope.
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const prompt_1 = require("../prompt");
+/** Resolve the team slug from --team or the stored default (undefined = personal scope). */
+function resolveTeam(ctx) {
+    return ctx.flags.team || (0, cloud_1.loadConfig)().teamSlug;
+}
+/** Read process.stdin to completion as a UTF-8 string. */
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+const list = (0, framework_1.defineCommand)({
+    name: 'secrets list',
+    description: 'List secrets in the vault (values are never shown).',
+    group: 'Secrets',
+    flags: [
+        { name: 'team', type: 'string', description: 'Team slug (defaults to the selected team).' },
+        { name: 'limit', type: 'number', description: 'Max secrets to return.', default: 50 },
+        { name: 'offset', type: 'number', description: 'Skip this many secrets.' },
+        { name: 'json', type: 'boolean', description: 'Output raw JSON.' },
+    ],
+    examples: [
+        'orm-cli secrets list',
+        'orm-cli secrets list --team acme --limit 100 --offset 100',
+        'orm-cli secrets list --json',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        const data = await (0, cloud_1.api)('/api/dashboard/secrets', {
+            query: {
+                team,
+                limit: typeof ctx.flags.limit === 'number' ? ctx.flags.limit : undefined,
+                offset: typeof ctx.flags.offset === 'number' ? ctx.flags.offset : undefined,
+            },
+        });
+        if (ctx.flags.json) {
+            framework_1.out.json(data);
+            return 0;
+        }
+        framework_1.out.table(data.secrets.map((s) => ({ name: s.name, updatedAt: s.updatedAt })));
+        return 0;
+    },
+});
+const get = (0, framework_1.defineCommand)({
+    name: 'secrets get',
+    description: 'Fetch a secret. The value is masked unless --reveal or --json is given.',
+    group: 'Secrets',
+    positionals: [{ name: 'name', description: 'The secret name.', required: true }],
+    flags: [
+        { name: 'team', type: 'string', description: 'Team slug (defaults to the selected team).' },
+        { name: 'json', type: 'boolean', description: 'Output raw JSON (includes the value).' },
+        { name: 'reveal', type: 'boolean', description: 'Print the raw secret value.' },
+    ],
+    examples: [
+        'orm-cli secrets get DATABASE_URL',
+        'orm-cli secrets get DATABASE_URL --reveal',
+        'orm-cli secrets get DATABASE_URL --team acme --json',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        const name = ctx.positionals[0];
+        const data = await (0, cloud_1.api)('/api/dashboard/secrets/' + encodeURIComponent(name), {
+            query: { team },
+        });
+        if (ctx.flags.json) {
+            framework_1.out.json(data);
+            return 0;
+        }
+        if (ctx.flags.reveal) {
+            framework_1.out.warn(`Revealing secret value for ${data.name}.`);
+            framework_1.out.info(data.value);
+            return 0;
+        }
+        framework_1.out.info(`${data.name}: ${'*'.repeat(data.value.length)} (${data.value.length} chars, hidden — use --reveal)`);
+        return 0;
+    },
+});
+const set = (0, framework_1.defineCommand)({
+    name: 'secrets set',
+    description: 'Set (create or update) a secret value in the vault.',
+    group: 'Secrets',
+    positionals: [
+        { name: 'name', description: 'The secret name.', required: true },
+        { name: 'value', description: "The secret value (use '-' for stdin; omit to be prompted hidden)." },
+    ],
+    flags: [{ name: 'team', type: 'string', description: 'Team slug (defaults to the selected team).' }],
+    examples: [
+        'orm-cli secrets set DATABASE_URL postgres://…',
+        'orm-cli secrets set DATABASE_URL - < secret.txt',
+        'orm-cli secrets set API_TOKEN   # prompts for the value with no echo',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        const name = ctx.positionals[0];
+        let value = ctx.positionals[1];
+        if (value === '-') {
+            // Reading from stdin: don't try to prompt.
+            value = await readStdin();
+        }
+        else if (value === undefined) {
+            // No value on the command line — prompt hidden so it never hits shell history.
+            value = await (0, prompt_1.promptHidden)(`Value for ${name}: `);
+            if (!value) {
+                framework_1.out.error('No value provided.');
+                return 1;
+            }
+        }
+        await (0, cloud_1.api)('/api/dashboard/secrets/' + encodeURIComponent(name), {
+            method: 'PUT',
+            body: { value },
+            query: { team },
+        });
+        framework_1.out.success(`Set secret ${name}`);
+        return 0;
+    },
+});
+const rm = (0, framework_1.defineCommand)({
+    name: 'secrets rm',
+    description: 'Remove a secret from the vault.',
+    group: 'Secrets',
+    positionals: [{ name: 'name', description: 'The secret name.', required: true }],
+    flags: [
+        { name: 'team', type: 'string', description: 'Team slug (defaults to the selected team).' },
+        { name: 'yes', alias: 'y', type: 'boolean', description: 'Skip confirmation.' },
+    ],
+    examples: [
+        'orm-cli secrets rm OLD_TOKEN',
+        'orm-cli secrets rm OLD_TOKEN --yes',
+        'orm-cli secrets rm OLD_TOKEN --team acme -y',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const team = resolveTeam(ctx);
+        const name = ctx.positionals[0];
+        const assumeYes = ctx.flags.yes === true || (0, framework_1.getGlobalOptions)().assumeYes;
+        framework_1.out.warn(`This will permanently delete secret ${name}.`);
+        if (!(await (0, prompt_1.confirm)(`Delete secret ${name}?`, { assumeYes, default: false }))) {
+            framework_1.out.info('Aborted (pass --yes to skip this prompt in a non-interactive session).');
+            return 1;
+        }
+        await (0, cloud_1.api)('/api/dashboard/secrets/' + encodeURIComponent(name), {
+            method: 'DELETE',
+            query: { team },
+        });
+        framework_1.out.success(`Removed secret ${name}`);
+        return 0;
+    },
+});
+exports.commands = [list, get, set, rm];

package/dist/cli/commands/store.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];