@true-sight/model-cli 1.0.0

package/dist/build/assemble-manifest.d.ts

@@ -0,0 +1,2 @@
+import { type ManifestModel, type ModelManifest } from '@true-sight/model-schema';
+export declare function assembleManifest(models: ManifestModel[]): ModelManifest;

package/dist/build/assemble-manifest.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleManifest = assembleManifest;
+const model_schema_1 = require("@true-sight/model-schema");
+function assembleManifest(models) {
+    return {
+        schemaVersion: model_schema_1.SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        models,
+    };
+}

package/dist/build/compile-entry.d.ts

@@ -0,0 +1,5 @@
+export type CompiledEntry = {
+    jsPath: string;
+    cleanup: () => void;
+};
+export declare function compileEntryIfNeeded(absoluteEntry: string): Promise<CompiledEntry>;

package/dist/build/compile-entry.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileEntryIfNeeded = compileEntryIfNeeded;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function findProjectTsconfig(absoluteEntry) {
+    let dir = (0, node_path_1.dirname)(absoluteEntry);
+    while (dir !== (0, node_path_1.dirname)(dir)) {
+        const candidate = (0, node_path_1.join)(dir, 'tsconfig.json');
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            if (absoluteEntry.includes(`${(0, node_path_1.join)('packages', 'model-cli', 'test', 'fixtures')}`)) {
+                return undefined;
+            }
+            return candidate;
+        }
+        dir = (0, node_path_1.dirname)(dir);
+    }
+    return undefined;
+}
+function writeFixtureTsconfig(absoluteEntry, tempDir) {
+    const entryDir = (0, node_path_1.dirname)(absoluteEntry);
+    const compileConfigPath = (0, node_path_1.join)(tempDir, 'compile-tsconfig.json');
+    (0, node_fs_1.writeFileSync)(compileConfigPath, JSON.stringify({
+        compilerOptions: {
+            target: 'ES2023',
+            module: 'nodenext',
+            moduleResolution: 'nodenext',
+            strict: false,
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            outDir: tempDir,
+            rootDir: entryDir,
+        },
+        include: [absoluteEntry],
+    }));
+    return compileConfigPath;
+}
+function readRootDir(tsconfigPath, absoluteEntry) {
+    const config = JSON.parse((0, node_fs_1.readFileSync)(tsconfigPath, 'utf8'));
+    if (config.compilerOptions?.rootDir) {
+        return (0, node_path_1.resolve)((0, node_path_1.dirname)(tsconfigPath), config.compilerOptions.rootDir);
+    }
+    return (0, node_path_1.dirname)(absoluteEntry);
+}
+async function compileEntryIfNeeded(absoluteEntry) {
+    if (!absoluteEntry.endsWith('.ts')) {
+        return { jsPath: absoluteEntry, cleanup: () => undefined };
+    }
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-cli-compile-'));
+    const projectTsconfig = findProjectTsconfig(absoluteEntry);
+    const compileConfigPath = projectTsconfig
+        ? projectTsconfig
+        : writeFixtureTsconfig(absoluteEntry, tempDir);
+    const tscArgs = projectTsconfig
+        ? ['tsc', '-p', compileConfigPath, '--outDir', tempDir, '--noCheck']
+        : ['tsc', '-p', compileConfigPath, '--noCheck'];
+    const result = (0, node_child_process_1.spawnSync)('npx', tscArgs, {
+        encoding: 'utf8',
+        cwd: projectTsconfig ? (0, node_path_1.dirname)(projectTsconfig) : undefined,
+    });
+    if (result.status !== 0) {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+        const message = (result.stderr || result.stdout || 'tsc failed').trim();
+        throw new Error(message);
+    }
+    const rootDir = readRootDir(projectTsconfig ?? compileConfigPath, absoluteEntry);
+    const relJs = (0, node_path_1.relative)(rootDir, absoluteEntry).replace(/\.ts$/, '.js');
+    const jsPath = (0, node_path_1.join)(tempDir, relJs);
+    if (!(0, node_fs_1.existsSync)(jsPath)) {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+        throw new Error(`Compiled entry not found: ${jsPath}`);
+    }
+    return {
+        jsPath,
+        cleanup: () => (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true }),
+    };
+}

package/dist/build/load-entry-runner.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/build/load-entry-runner.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const model_schema_1 = require("@true-sight/model-schema");
+const node_module_1 = require("node:module");
+const node_url_1 = require("node:url");
+const requireEntry = (0, node_module_1.createRequire)(__filename);
+function isModelConstructor(value) {
+    return typeof value === 'function';
+}
+async function loadEntry(entryPath) {
+    if (entryPath.endsWith('.cjs')) {
+        return requireEntry(entryPath);
+    }
+    return (await import((0, node_url_1.pathToFileURL)(entryPath).href));
+}
+async function main() {
+    const entryPath = process.argv[2];
+    if (!entryPath) {
+        console.error('Missing entry path');
+        process.exit(1);
+    }
+    try {
+        const loaded = await loadEntry(entryPath);
+        const models = loaded.models ?? loaded.default?.models;
+        if (!Array.isArray(models)) {
+            console.error('Entry must export `models` array of model classes');
+            process.exit(1);
+        }
+        if (!models.every(isModelConstructor)) {
+            console.error('Entry must export model class constructors in `models`');
+            process.exit(1);
+        }
+        process.stdout.write(JSON.stringify((0, model_schema_1.compileModels)(models)));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/dist/build/load-entry.d.ts

@@ -0,0 +1,5 @@
+import type { ManifestModel } from '@true-sight/model-schema';
+export declare class LoadEntryError extends Error {
+    constructor(message: string);
+}
+export declare function loadModelsFromEntry(entryPath: string, cwd: string): Promise<ManifestModel[]>;

package/dist/build/load-entry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadEntryError = void 0;
+exports.loadModelsFromEntry = loadModelsFromEntry;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const compile_entry_js_1 = require("./compile-entry.js");
+class LoadEntryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LoadEntryError';
+    }
+}
+exports.LoadEntryError = LoadEntryError;
+function resolveNodePath(cwd) {
+    const candidates = [];
+    let dir = cwd;
+    while (dir !== (0, node_path_1.dirname)(dir)) {
+        candidates.push((0, node_path_1.join)(dir, 'node_modules'));
+        dir = (0, node_path_1.dirname)(dir);
+    }
+    return candidates.filter(node_fs_1.existsSync).join(process.platform === 'win32' ? ';' : ':');
+}
+function resolveRunnerPath() {
+    const adjacent = (0, node_path_1.resolve)((0, node_path_1.dirname)(__filename), 'load-entry-runner.js');
+    if ((0, node_fs_1.existsSync)(adjacent)) {
+        return adjacent;
+    }
+    const packageDist = (0, node_path_1.resolve)((0, node_path_1.dirname)(__filename), '../../dist/build/load-entry-runner.js');
+    if ((0, node_fs_1.existsSync)(packageDist)) {
+        return packageDist;
+    }
+    throw new LoadEntryError('Run npm run build -w @true-sight/model-cli first');
+}
+async function loadModelsFromEntry(entryPath, cwd) {
+    const absoluteEntry = (0, node_path_1.resolve)(cwd, entryPath);
+    if (!(0, node_fs_1.existsSync)(absoluteEntry)) {
+        throw new LoadEntryError(`Entry file not found: ${entryPath}`);
+    }
+    const { jsPath, cleanup } = await (0, compile_entry_js_1.compileEntryIfNeeded)(absoluteEntry);
+    const runnerPath = resolveRunnerPath();
+    try {
+        const result = (0, node_child_process_1.spawnSync)(process.execPath, [runnerPath, jsPath], {
+            encoding: 'utf8',
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            env: {
+                ...process.env,
+                NODE_PATH: resolveNodePath(cwd),
+            },
+        });
+        if (result.status !== 0) {
+            const message = (result.stderr || result.stdout || 'Failed to load entry').trim();
+            throw new LoadEntryError(message);
+        }
+        return JSON.parse(result.stdout);
+    }
+    finally {
+        cleanup();
+    }
+}

package/dist/build/write-manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ModelManifest } from '@true-sight/model-schema';
+export declare function writeManifest(manifest: ModelManifest, outPath: string, cwd: string): void;

package/dist/build/write-manifest.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeManifest = writeManifest;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MANIFEST_KEY_ORDER = [
+    'schemaVersion',
+    'generatedAt',
+    'sourceCommit',
+    'models',
+];
+const MODEL_KEY_ORDER = ['name', 'label', 'connectionName', 'explores'];
+const EXPLORE_KEY_ORDER = ['name', 'label', 'from', 'joins', 'views'];
+const VIEW_KEY_ORDER = [
+    'name',
+    'label',
+    'sql',
+    'dimensions',
+    'measurements',
+];
+function orderKeys(value, keyOrder) {
+    const ordered = {};
+    for (const key of keyOrder) {
+        if (key in value) {
+            ordered[key] = value[key];
+        }
+    }
+    for (const key of Object.keys(value)) {
+        if (!(key in ordered)) {
+            ordered[key] = value[key];
+        }
+    }
+    return ordered;
+}
+function stableManifest(manifest) {
+    return orderKeys({
+        ...manifest,
+        models: manifest.models.map((model) => orderKeys({
+            ...model,
+            explores: model.explores.map((explore) => orderKeys({
+                ...explore,
+                views: explore.views.map((view) => orderKeys({ ...view }, VIEW_KEY_ORDER)),
+            }, EXPLORE_KEY_ORDER)),
+        }, MODEL_KEY_ORDER)),
+    }, MANIFEST_KEY_ORDER);
+}
+function writeManifest(manifest, outPath, cwd) {
+    const absoluteOut = (0, node_path_1.resolve)(cwd, outPath);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(absoluteOut), { recursive: true });
+    const json = `${JSON.stringify(stableManifest(manifest), null, 2)}\n`;
+    (0, node_fs_1.writeFileSync)(absoluteOut, json, 'utf8');
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const build_js_1 = require("./commands/build.js");
+const sync_js_1 = require("./commands/sync.js");
+const validate_js_1 = require("./commands/validate.js");
+const program = new commander_1.Command();
+program.name('truesight-model').description('True Sight model manifest CLI');
+program
+    .command('build')
+    .description('Compile TS model definitions into manifest JSON')
+    .argument('[entry]', 'entry module path', 'src/index.ts')
+    .option('--out <path>', 'output manifest path', 'true-sight/manifest.json')
+    .action(async (entry, options) => {
+    const exitCode = await (0, build_js_1.runBuild)({ entry, out: options.out });
+    process.exit(exitCode);
+});
+program
+    .command('validate')
+    .description('Validate a pre-built manifest JSON file')
+    .argument('[path]', 'manifest path', 'true-sight/manifest.json')
+    .action(async (path) => {
+    const exitCode = await (0, validate_js_1.runValidate)({ path });
+    process.exit(exitCode);
+});
+program
+    .command('sync')
+    .description('Upload local manifest JSON to True Sight')
+    .argument('[path]', 'manifest path', 'true-sight/manifest.json')
+    .option('--url <url>', 'sync endpoint URL')
+    .option('--secret <secret>', 'HMAC signing secret')
+    .action(async (path, options) => {
+    const exitCode = await (0, sync_js_1.runSync)({
+        path,
+        url: options.url,
+        secret: options.secret,
+    });
+    process.exit(exitCode);
+});
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/dist/commands/build.d.ts

@@ -0,0 +1,6 @@
+export interface BuildOptions {
+    entry: string;
+    out: string;
+    cwd?: string;
+}
+export declare function runBuild(options: BuildOptions): Promise<number>;

package/dist/commands/build.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuild = runBuild;
+const model_schema_1 = require("@true-sight/model-schema");
+const assemble_manifest_js_1 = require("../build/assemble-manifest.js");
+const load_entry_js_1 = require("../build/load-entry.js");
+const write_manifest_js_1 = require("../build/write-manifest.js");
+const print_errors_js_1 = require("../util/print-errors.js");
+async function runBuild(options) {
+    const cwd = options.cwd ?? process.cwd();
+    try {
+        const models = await (0, load_entry_js_1.loadModelsFromEntry)(options.entry, cwd);
+        const manifest = (0, assemble_manifest_js_1.assembleManifest)(models);
+        const validation = (0, model_schema_1.validateManifest)(manifest);
+        if (!validation.ok) {
+            (0, print_errors_js_1.printValidationErrors)(validation.errors);
+            return 1;
+        }
+        (0, write_manifest_js_1.writeManifest)(manifest, options.out, cwd);
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof load_entry_js_1.LoadEntryError) {
+            console.error(error.message);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,7 @@
+export interface SyncOptions {
+    path: string;
+    url?: string;
+    secret?: string;
+    cwd?: string;
+}
+export declare function runSync(options: SyncOptions): Promise<number>;

package/dist/commands/sync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSync = runSync;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const dotenv_1 = require("dotenv");
+const model_schema_1 = require("@true-sight/model-schema");
+const post_manifest_js_1 = require("../sync/post-manifest.js");
+const sign_body_js_1 = require("../sync/sign-body.js");
+const print_errors_js_1 = require("../util/print-errors.js");
+async function runSync(options) {
+    const cwd = options.cwd ?? process.cwd();
+    (0, dotenv_1.config)({ path: (0, node_path_1.resolve)(cwd, '.env') });
+    const url = options.url ?? process.env.TRUESIGHT_SYNC_URL;
+    const secret = options.secret ?? process.env.TRUESIGHT_SYNC_SECRET;
+    if (!url || !secret) {
+        console.error('Sync requires TRUESIGHT_SYNC_URL and TRUESIGHT_SYNC_SECRET (or --url / --secret flags)');
+        return 1;
+    }
+    const absolutePath = (0, node_path_1.resolve)(cwd, options.path);
+    const rawBody = (0, node_fs_1.readFileSync)(absolutePath);
+    let parsed;
+    try {
+        parsed = JSON.parse(rawBody.toString('utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to read manifest at ${options.path}: ${message}`);
+        return 1;
+    }
+    const validation = (0, model_schema_1.validateManifest)(parsed);
+    if (!validation.ok) {
+        (0, print_errors_js_1.printValidationErrors)(validation.errors);
+        return 1;
+    }
+    const signatureHeader = (0, sign_body_js_1.signManifestBody)(rawBody, secret);
+    try {
+        const response = await (0, post_manifest_js_1.postManifest)(url, rawBody, signatureHeader);
+        if (response.status < 200 || response.status >= 300) {
+            console.error(`Sync failed (${response.status}): ${response.body}`);
+            return 1;
+        }
+        console.log(`Sync succeeded (${response.status})`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Sync request failed: ${message}`);
+        return 1;
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,5 @@
+export interface ValidateOptions {
+    path: string;
+    cwd?: string;
+}
+export declare function runValidate(options: ValidateOptions): Promise<number>;

package/dist/commands/validate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidate = runValidate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const model_schema_1 = require("@true-sight/model-schema");
+const print_errors_js_1 = require("../util/print-errors.js");
+async function runValidate(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const absolutePath = (0, node_path_1.resolve)(cwd, options.path);
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(absolutePath, 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to read manifest at ${options.path}: ${message}`);
+        return 1;
+    }
+    const validation = (0, model_schema_1.validateManifest)(parsed);
+    if (!validation.ok) {
+        (0, print_errors_js_1.printValidationErrors)(validation.errors);
+        return 1;
+    }
+    return 0;
+}

package/dist/sync/post-manifest.d.ts

@@ -0,0 +1,5 @@
+export interface PostManifestResult {
+    status: number;
+    body: string;
+}
+export declare function postManifest(url: string, rawBody: Buffer, signatureHeader: string): Promise<PostManifestResult>;

package/dist/sync/post-manifest.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postManifest = postManifest;
+async function postManifest(url, rawBody, signatureHeader) {
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-True-Sight-Signature-256': signatureHeader,
+        },
+        body: new Uint8Array(rawBody),
+    });
+    const body = await response.text();
+    return { status: response.status, body };
+}

package/dist/sync/sign-body.d.ts

@@ -0,0 +1 @@
+export declare function signManifestBody(rawBody: Buffer, secret: string): string;

package/dist/sync/sign-body.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signManifestBody = signManifestBody;
+const node_crypto_1 = require("node:crypto");
+function signManifestBody(rawBody, secret) {
+    const digest = (0, node_crypto_1.createHmac)('sha256', secret).update(rawBody).digest('hex');
+    return `sha256=${digest}`;
+}

package/dist/util/print-errors.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestValidationError } from '@true-sight/model-schema';
+export declare function printValidationErrors(errors: ManifestValidationError[]): void;

package/dist/util/print-errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printValidationErrors = printValidationErrors;
+function printValidationErrors(errors) {
+    for (const error of errors) {
+        const prefix = error.path ? `${error.path}: ` : '';
+        console.error(`${prefix}${error.message}`);
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@true-sight/model-cli",
+  "version": "1.0.0",
+  "bin": {
+    "truesight-model": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "pretest": "npm run build -w @true-sight/model-schema && npm run build",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@true-sight/model-schema": "^1.0.0",
+    "commander": "^13.1.0",
+    "dotenv": "^16.6.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.0.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": ".",
+    "testMatch": [
+      "**/test/**/*.spec.ts"
+    ],
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "testEnvironment": "node"
+  }
+}