@cms0/cms0 0.0.1

package/dist/cjs/libs/cli/descriptor-builder.cjs

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDescriptor = buildDescriptor;
+// Build a schema descriptor by inspecting user types with ts-morph.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const config_loader_js_1 = require("./config-loader.cjs");
+function unwrapOptional(type) {
+    let optional = false;
+    let nullable = false;
+    if (type.isUnion()) {
+        const unionTypes = type.getUnionTypes();
+        const filtered = unionTypes.filter((t) => {
+            if (t.isNull()) {
+                nullable = true;
+                return false;
+            }
+            if (t.isUndefined()) {
+                optional = true;
+                return false;
+            }
+            return true;
+        });
+        if (filtered.length === 1) {
+            return { base: filtered[0], optional, nullable };
+        }
+    }
+    return { base: type, optional, nullable };
+}
+function getDescriptorForType(type, modelMap, warnings, ctx, opts) {
+    const { base, optional, nullable } = unwrapOptional(type);
+    const isOptional = !!opts?.optional || optional;
+    const isNullable = !!opts?.nullable || nullable;
+    if (base.isString()) {
+        return {
+            kind: "primitive",
+            type: "string",
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isNumber()) {
+        return {
+            kind: "primitive",
+            type: "number",
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isBoolean()) {
+        return {
+            kind: "primitive",
+            type: "boolean",
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isArray()) {
+        const elem = base.getArrayElementTypeOrThrow();
+        return {
+            kind: "array",
+            type: "array",
+            items: getDescriptorForType(elem, modelMap, warnings, `${ctx}[]`),
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    const aliasSymbol = base.getAliasSymbol();
+    if (aliasSymbol) {
+        const name = aliasSymbol.getName();
+        if (modelMap[name]) {
+            return {
+                kind: "modelRef",
+                model: name,
+                optional: isOptional,
+                nullable: isNullable,
+            };
+        }
+    }
+    if (base.isObject() && !base.isInterface()) {
+        const props = {};
+        for (const prop of base.getProperties()) {
+            const propDecl = prop.getDeclarations()[0];
+            const analyzed = unwrapOptional(propDecl.getType());
+            props[prop.getName()] = getDescriptorForType(analyzed.base, modelMap, warnings, `${ctx}.${prop.getName()}`, {
+                optional: prop.isOptional() || analyzed.optional,
+                nullable: analyzed.nullable,
+            });
+        }
+        return {
+            kind: "object",
+            type: "object",
+            properties: props,
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    // unsupported or unknown type; fall back to string and record warning
+    warnings.add(`cms0: unsupported type at ${ctx}; falling back to string`);
+    return {
+        kind: "primitive",
+        type: "string",
+        optional: isOptional,
+        nullable: isNullable,
+    };
+}
+function collectModels(sourceFiles, modelMap, warnings) {
+    sourceFiles.forEach((sf) => {
+        sf.getTypeAliases().forEach((alias) => {
+            if (!alias.hasExportKeyword())
+                return;
+            const name = alias.getName();
+            const type = alias.getType();
+            if (type.isObject()) {
+                const props = {};
+                for (const prop of type.getProperties()) {
+                    const decl = prop.getDeclarations()[0];
+                    const propType = decl.getType();
+                    props[prop.getName()] = getDescriptorForType(propType, modelMap, warnings, `model ${name}.${prop.getName()}`);
+                }
+                modelMap[name] = { kind: "model", properties: props };
+            }
+        });
+    });
+}
+function findRootType(sourceFiles) {
+    for (const sf of sourceFiles) {
+        const invoc = sf
+            ?.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+            .find((call) => call.getExpression().getText() === "cms0");
+        if (invoc) {
+            const typeArgs = invoc.getTypeArguments();
+            if (typeArgs.length > 0) {
+                return typeArgs[0].getType();
+            }
+        }
+    }
+    return undefined;
+}
+function buildDescriptor(resolved) {
+    const tsconfig = resolved.tsconfigPath ?? (0, config_loader_js_1.findTsConfig)(resolved.entryFile);
+    const project = tsconfig
+        ? new ts_morph_1.Project({ tsConfigFilePath: tsconfig })
+        : new ts_morph_1.Project();
+    const warnings = new Set();
+    const entryDir = path_1.default.dirname(path_1.default.resolve(resolved.entryFile));
+    if (!project.getSourceFile(resolved.entryFile) &&
+        fs_1.default.existsSync(resolved.entryFile)) {
+        project.addSourceFileAtPath(resolved.entryFile);
+    }
+    const sourceFiles = project.getSourceFiles().filter((sf) => {
+        const filePath = path_1.default.resolve(sf.getFilePath());
+        const rel = path_1.default.relative(entryDir, filePath);
+        return rel && !rel.startsWith("..") && !path_1.default.isAbsolute(rel);
+    });
+    const modelMap = {};
+    collectModels(sourceFiles, modelMap, warnings);
+    const rootType = findRootType(sourceFiles);
+    if (!rootType) {
+        throw new Error("Could not locate cms0<T>() invocation in project sources.");
+    }
+    const roots = {};
+    for (const prop of rootType.getProperties()) {
+        const name = prop.getName();
+        const decl = prop.getDeclarations()[0];
+        const analyzed = unwrapOptional(decl.getType());
+        const propType = analyzed.base;
+        const propOptional = prop.isOptional() || analyzed.optional;
+        const propNullable = analyzed.nullable;
+        if (propType.isArray()) {
+            const elem = propType.getArrayElementTypeOrThrow();
+            const itemDesc = getDescriptorForType(elem, modelMap, warnings, `root ${name}[]`);
+            roots[name] = {
+                type: "array",
+                items: itemDesc,
+                optional: propOptional,
+                nullable: propNullable,
+            };
+        }
+        else if (propType.isObject() && !propType.isArray()) {
+            const objDesc = getDescriptorForType(propType, modelMap, warnings, `root ${name}`, {
+                optional: propOptional,
+                nullable: propNullable,
+            });
+            if (objDesc.kind === "object") {
+                roots[name] = {
+                    type: "object",
+                    properties: objDesc.properties,
+                    optional: propOptional,
+                    nullable: propNullable,
+                };
+            }
+            else if (objDesc.kind === "modelRef") {
+                roots[name] = {
+                    type: "object",
+                    properties: {},
+                    optional: propOptional,
+                    nullable: propNullable,
+                };
+            }
+            else {
+                roots[name] = {
+                    type: "object",
+                    properties: {},
+                    optional: propOptional,
+                    nullable: propNullable,
+                };
+            }
+        }
+        else {
+            roots[name] = {
+                type: "object",
+                properties: {
+                    [name]: getDescriptorForType(propType, modelMap, warnings, `root ${name}.${name}`, {
+                        optional: propOptional,
+                        nullable: propNullable,
+                    }),
+                },
+                optional: propOptional,
+                nullable: propNullable,
+            };
+        }
+    }
+    if (warnings.size) {
+        warnings.forEach((w) => console.warn(w));
+    }
+    return { models: modelMap, roots };
+}

package/dist/cjs/libs/cli/descriptor-writer.cjs

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDescriptorFile = writeDescriptorFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function writeDescriptorFile(descriptor, outputPath) {
+    const output = `// Auto-generated schema descriptor\nexport const schemaDescriptor = ${JSON.stringify(descriptor, null, 2)} as const;\n`;
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(outputPath), { recursive: true });
+        fs_1.default.writeFileSync(outputPath, output, "utf8");
+    }
+    catch (err) {
+        if (err?.code === "EPERM" || err?.code === "EACCES") {
+            console.warn(`cms0: skipped writing descriptor (no write permission): ${outputPath}`);
+        }
+        else {
+            throw err;
+        }
+    }
+}

package/dist/cjs/libs/cli/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFromCli = exports.startWatcher = exports.buildOnce = void 0;
+// Public surface for cms0 CLI utilities.
+var build_js_1 = require("./build.cjs");
+Object.defineProperty(exports, "buildOnce", { enumerable: true, get: function () { return build_js_1.buildOnce; } });
+var watcher_js_1 = require("./watcher.cjs");
+Object.defineProperty(exports, "startWatcher", { enumerable: true, get: function () { return watcher_js_1.startWatcher; } });
+var cli_js_1 = require("./cli.cjs");
+Object.defineProperty(exports, "runFromCli", { enumerable: true, get: function () { return cli_js_1.runFromCli; } });

package/dist/cjs/libs/cli/paths.cjs

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageRoot = exports.descriptorOutPath = void 0;
+// Path utilities for locating package-relative outputs.
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const importMetaUrl = (() => {
+    try {
+        // Avoid syntax that breaks CommonJS compilation; evaluate only if supported
+        // eslint-disable-next-line no-new-func
+        return Function("return import.meta.url")();
+    }
+    catch {
+        return undefined;
+    }
+})();
+const here = typeof __dirname === "string"
+    ? __dirname
+    : importMetaUrl
+        ? path_1.default.dirname((0, url_1.fileURLToPath)(importMetaUrl))
+        : process.cwd();
+const packageRoot = path_1.default.resolve(here, "../../..");
+exports.packageRoot = packageRoot;
+const descriptorOutPath = path_1.default.resolve(packageRoot, "src/generated/schema-descriptor.ts");
+exports.descriptorOutPath = descriptorOutPath;

package/dist/cjs/libs/cli/publisher.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishDescriptor = publishDescriptor;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const startSpinner = (label) => {
+    if (!process.stdout.isTTY) {
+        console.log(`${label}...`);
+        return {
+            stop: (message) => {
+                if (message)
+                    console.log(message);
+            },
+        };
+    }
+    const frames = ["|", "/", "-", "\\"];
+    let idx = 0;
+    const timer = setInterval(() => {
+        const frame = frames[idx % frames.length];
+        idx += 1;
+        process.stdout.write(`\r${frame} ${label}`);
+    }, 120);
+    return {
+        stop: (message) => {
+            clearInterval(timer);
+            process.stdout.write("\r");
+            if (message)
+                process.stdout.write(`${message}\n`);
+        },
+    };
+};
+async function waitForAdminReady(baseUrl, headers) {
+    const healthUrl = `${baseUrl.replace(/\/$/, "")}/ok`;
+    const maxWaitMs = 30_000;
+    const startedAt = Date.now();
+    const spinner = startSpinner("cms0: waiting for admin to reload");
+    await sleep(250);
+    let attempt = 0;
+    while (Date.now() - startedAt < maxWaitMs) {
+        attempt += 1;
+        try {
+            const res = await fetch(healthUrl, { headers });
+            if (res.ok) {
+                spinner.stop("cms0: admin ready");
+                return true;
+            }
+        }
+        catch {
+            // ignore transient errors during restart
+        }
+        await sleep(Math.min(500 + attempt * 250, 2000));
+    }
+    spinner.stop("cms0: admin restart timed out");
+    return false;
+}
+async function publishDescriptor(resolved, descriptor) {
+    if (!resolved.apiBaseUrl)
+        return;
+    try {
+        const payload = {
+            version: new Date().toISOString(),
+            descriptor,
+        };
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (resolved.apiKey) {
+            headers["Authorization"] = `Bearer ${resolved.apiKey}`;
+        }
+        const target = `${resolved.apiBaseUrl.replace(/\/$/, "")}/schema`;
+        const maxAttempts = 5;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const res = await fetch(target, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(payload),
+                });
+                if (!res.ok) {
+                    throw new Error(`status ${res.status}`);
+                }
+                const ready = await waitForAdminReady(resolved.apiBaseUrl.replace(/\/$/, ""), headers);
+                if (!ready) {
+                    console.warn("cms0: publish succeeded, but admin did not become healthy in time.");
+                }
+                console.log(`cms0: published descriptor to ${target}`);
+                return;
+            }
+            catch (err) {
+                const waitMs = Math.min(2000 * attempt, 5000);
+                console.warn(`cms0: publish attempt ${attempt}/${maxAttempts} failed (${err instanceof Error ? err.message : err}).` + (attempt < maxAttempts ? ` retrying in ${waitMs}ms...` : ""));
+                if (attempt < maxAttempts) {
+                    await new Promise((r) => setTimeout(r, waitMs));
+                }
+                else {
+                    console.warn("cms0: giving up on publishing descriptor for now.");
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`cms0: failed to publish descriptor ${err instanceof Error ? err.message : err}`, err);
+    }
+}

package/dist/cjs/libs/cli/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// Descriptor types come from @cms0/shared; this file extends with CLI-only config.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/libs/cli/watcher.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatcher = startWatcher;
+// File watcher that rebuilds descriptors on entry changes.
+const chokidar_1 = __importDefault(require("chokidar"));
+const build_js_1 = require("./build.cjs");
+function startWatcher(resolved, afterBuild) {
+    const watcher = chokidar_1.default.watch([resolved.entryFile], {
+        ignoreInitial: false,
+    });
+    const run = (after) => {
+        try {
+            const descriptor = (0, build_js_1.buildOnce)(resolved);
+            if (after) {
+                Promise.resolve(after(descriptor)).catch((err) => {
+                    console.error("cms0: post-build hook failed", err);
+                });
+            }
+        }
+        catch (err) {
+            console.error("cms0: generation failed", err);
+        }
+    };
+    // Trigger a build on startup and whenever the entry file changes.
+    watcher.on("ready", () => run(afterBuild));
+    watcher.on("change", () => run(afterBuild));
+    watcher.on("error", (error) => {
+        console.error("cms0: watcher error", error);
+    });
+    return watcher;
+}

package/dist/cjs/schema-descriptors.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaDescriptor = void 0;
+var schema_descriptor_1 = require("@cms0/cms0/generated/schema-descriptor");
+Object.defineProperty(exports, "schemaDescriptor", { enumerable: true, get: function () { return schema_descriptor_1.schemaDescriptor; } });

package/dist/cjs/utils/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Entry point for the cms0 CLI binary.
+// Use local sources directly to avoid pulling stale dist via package exports.
+import { runFromCli } from "./libs/cli/index.js";
+runFromCli();

package/dist/esm/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}