ts-prorm-orm 1.1.0 → 1.2.0

package/dist/cli/commands/user.js

@@ -0,0 +1,171 @@
+"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;
+// User command module for the prorm CLI. Manages the signed-in user's profile
+// via the dashboard API (`/api/dashboard/user`). Avatar uploads reuse the
+// storage presign/commit flow so image bytes flow directly between the CLI and
+// S3, then the profile is patched to reference the uploaded object.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const io_1 = require("../io");
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const AVATAR_CONTENT_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+function avatarContentTypeFor(file) {
+    return AVATAR_CONTENT_TYPES[path.extname(file).toLowerCase()] ?? 'application/octet-stream';
+}
+/** Read an optional string flag, treating empty strings as absent. */
+function str(ctx, name) {
+    const v = ctx.flags[name];
+    return typeof v === 'string' && v ? v : undefined;
+}
+/** The profile fields shown in the readable key/value view, in display order. */
+const PROFILE_FIELDS = [
+    'id',
+    'email',
+    'name',
+    'username',
+    'bio',
+    'company',
+    'location',
+    'website',
+    'avatarUrl',
+    'createdAt',
+];
+// ─── Commands ─────────────────────────────────────────────────────────────────
+const get = (0, framework_1.defineCommand)({
+    name: 'user get',
+    description: "Show the signed-in user's profile.",
+    group: 'User',
+    flags: [{ name: 'json', type: 'boolean', description: 'Output raw JSON.' }],
+    examples: ['orm-cli user get', 'orm-cli user get --json'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const user = await (0, cloud_1.api)('/api/dashboard/user');
+        if (ctx.flags.json) {
+            framework_1.out.json(user);
+            return;
+        }
+        framework_1.out.table(PROFILE_FIELDS.map((field) => ({ field, value: user[field] ?? '' })));
+    },
+});
+const update = (0, framework_1.defineCommand)({
+    name: 'user update',
+    description: "Update the signed-in user's profile.",
+    group: 'User',
+    flags: [
+        { name: 'name', type: 'string', description: 'Display name.' },
+        { name: 'username', type: 'string', description: 'Unique username.' },
+        { name: 'bio', type: 'string', description: 'Short bio.' },
+        { name: 'company', type: 'string', description: 'Company or organization.' },
+        { name: 'location', type: 'string', description: 'Location.' },
+        { name: 'website', type: 'string', description: 'Website URL.' },
+    ],
+    examples: [
+        'orm-cli user update --name "Ada Lovelace"',
+        'orm-cli user update --username ada --company Analytical',
+        'orm-cli user update --bio "Building things." --location London',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const fields = ['name', 'username', 'bio', 'company', 'location', 'website'];
+        const body = {};
+        for (const field of fields) {
+            const value = str(ctx, field);
+            if (value !== undefined)
+                body[field] = value;
+        }
+        if (Object.keys(body).length === 0) {
+            framework_1.out.error('Nothing to update — pass at least one field.');
+            return 1;
+        }
+        const user = await (0, cloud_1.api)('/api/dashboard/user', { method: 'PATCH', body });
+        framework_1.out.success('Profile updated.');
+        framework_1.out.table(Object.keys(body).map((field) => ({ field, value: user[field] ?? '' })));
+        return 0;
+    },
+});
+const avatar = (0, framework_1.defineCommand)({
+    name: 'user avatar',
+    description: "Upload and set the signed-in user's avatar image.",
+    group: 'User',
+    positionals: [{ name: 'file', description: 'Path to the local image file.', required: true }],
+    examples: ['orm-cli user avatar ./me.png', 'orm-cli user avatar ~/pictures/avatar.jpg'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const file = ctx.positionals[0];
+        if (!fs.existsSync(file)) {
+            framework_1.out.error(`File not found: ${file}`);
+            return 1;
+        }
+        const name = path.basename(file);
+        const contentType = avatarContentTypeFor(file);
+        // Ask the dashboard for a presigned PUT so the bytes go straight to S3.
+        const { url, key } = await (0, cloud_1.api)('/api/dashboard/storage/presign', {
+            method: 'POST',
+            body: { name, kind: 'avatar', contentType, public: true },
+        });
+        // Stream the file so large images never fully buffer in memory.
+        const spin = (0, io_1.spinner)('Uploading avatar…');
+        let size;
+        try {
+            size = await (0, io_1.uploadFile)(url, file, contentType);
+        }
+        finally {
+            spin.stop();
+        }
+        // Commit the object, then point the profile at it — the server resolves the
+        // public URL from the committed avatar key.
+        await (0, cloud_1.api)('/api/dashboard/storage/commit', {
+            method: 'POST',
+            body: { key, kind: 'avatar', size, public: true },
+        });
+        await (0, cloud_1.api)('/api/dashboard/user', {
+            method: 'PATCH',
+            body: { avatarKey: key },
+        });
+        framework_1.out.success('Avatar updated.');
+        return 0;
+    },
+});
+exports.commands = [get, update, avatar];

package/dist/cli/framework.d.ts

@@ -0,0 +1,103 @@
+export type FlagType = 'string' | 'boolean' | 'number';
+export type OutputFormat = 'table' | 'json' | 'csv' | 'tsv';
+export interface FlagSpec {
+    /** Long name, e.g. "team" for --team. */
+    name: string;
+    /** Single-char alias, e.g. "t" for -t. */
+    alias?: string;
+    type: FlagType;
+    description: string;
+    required?: boolean;
+    default?: string | boolean | number;
+    /** Restrict to a set of values. */
+    choices?: string[];
+}
+export interface PositionalSpec {
+    name: string;
+    description: string;
+    required?: boolean;
+    choices?: string[];
+    variadic?: boolean;
+}
+export interface CommandContext {
+    positionals: string[];
+    flags: Record<string, string | boolean | number | undefined>;
+    /** Raw argv after the command name. */
+    raw: string[];
+}
+export interface Command {
+    /** Command name, may be namespaced with a space, e.g. "db add". */
+    name: string;
+    description: string;
+    /** Command group for `--help` (e.g. "Auth", "Databases", "Storage"). */
+    group?: string;
+    /** Alternate names that resolve to this command (e.g. "ls" for "list"). */
+    aliases?: string[];
+    positionals?: PositionalSpec[];
+    flags?: FlagSpec[];
+    examples?: string[];
+    run: (ctx: CommandContext) => Promise<number | void> | number | void;
+}
+export declare function defineCommand(cmd: Command): Command;
+export declare const EXIT: {
+    readonly OK: 0;
+    readonly ERROR: 1;
+    readonly USAGE: 2;
+    readonly AUTH: 3;
+    readonly NETWORK: 4;
+    readonly NOT_FOUND: 5;
+    readonly TIMEOUT: 124;
+};
+export interface GlobalOptions {
+    json: boolean;
+    output?: OutputFormat;
+    quiet: boolean;
+    verbose: boolean;
+    /** true = force color, false = disable, undefined = auto. */
+    color?: boolean;
+    apiUrl?: string;
+    team?: string;
+    assumeYes: boolean;
+    noInput: boolean;
+    profile?: string;
+    configPath?: string;
+    truncate: boolean;
+    timeoutSec?: number;
+}
+export declare function getGlobalOptions(): GlobalOptions;
+/** Flags accepted on every command (merged unless a command declares its own). */
+export declare const GLOBAL_FLAGS: FlagSpec[];
+export declare function register(...cmds: Command[]): void;
+export declare function getCommand(name: string): Command | undefined;
+export declare function allCommands(): Command[];
+/** Resolve a possibly multi-word command from argv (longest match wins). */
+export declare function resolveCommand(argv: string[]): {
+    cmd?: Command;
+    rest: string[];
+};
+/** Closest candidate to `input` within an edit-distance threshold, if any. */
+export declare function closest(input: string, candidates: string[]): string | undefined;
+/** Suggest a registered command (or alias) close to `name`. */
+export declare function suggestCommand(name: string): string | undefined;
+export declare function parseArgs(argv: string[], cmd: Command): CommandContext;
+/** A user/usage error (bad flags, missing args) — exits with EXIT.USAGE. */
+export declare class UsageError extends Error {
+}
+/** Apply global options to the output layer. Call once after parsing. */
+export declare function configureOutput(): void;
+export declare const out: {
+    info: (m: string) => void;
+    success: (m: string) => void;
+    warn: (m: string) => void;
+    error: (m: string) => void;
+    dim: (m: string) => void;
+    json: (v: unknown) => void;
+    table: (rows: Record<string, unknown>[]) => void;
+};
+export declare function commandHelp(cmd: Command): string;
+export declare function topLevelHelp(): string;
+/** Dispatch argv against the registry. Returns an exit code, or null if no
+ *  registered command matched (so the caller can fall back to legacy handling). */
+export declare function runRegistered(argv: string[]): Promise<number | null>;
+/** Map a thrown error to a script-friendly exit code. */
+export declare function exitCodeFor(err: unknown): number;