@cms0/cms0 0.0.1

package/dist/esm/libs/cli/config-loader.js

@@ -0,0 +1,168 @@
+// Load cms0.config files and resolve relevant paths for the CLI.
+import fs from "fs";
+import path from "path";
+import { pathToFileURL, fileURLToPath } from "url";
+import crypto from "crypto";
+const DEFAULT_CONFIG_BASENAMES = [
+    "cms0.config.ts",
+    "cms0.config.js",
+    "cms0.config.mjs",
+    "cms0.config.cjs",
+    "cms0.config.json",
+];
+function findConfigPath(provided) {
+    if (provided) {
+        const resolved = path.isAbsolute(provided)
+            ? provided
+            : path.resolve(process.cwd(), provided);
+        return fs.existsSync(resolved) ? resolved : undefined;
+    }
+    let dir = process.cwd();
+    while (true) {
+        for (const name of DEFAULT_CONFIG_BASENAMES) {
+            const candidate = path.join(dir, name);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function findNearestPackageJson(startPath) {
+    let dir = path.dirname(startPath);
+    while (true) {
+        const candidate = path.join(dir, "package.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function readPackageType(pkgJsonPath) {
+    try {
+        const raw = fs.readFileSync(pkgJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed?.type === "module"
+            ? "module"
+            : parsed?.type === "commonjs"
+                ? "commonjs"
+                : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadUserConfig(configPath) {
+    const resolvedPath = findConfigPath(configPath);
+    if (!resolvedPath) {
+        console.warn("cms0: no cms0.config.* file found; provide --config");
+        return undefined;
+    }
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (ext === ".json") {
+        const json = fs.readFileSync(resolvedPath, "utf8");
+        return { path: resolvedPath, config: JSON.parse(json) };
+    }
+    if (ext === ".ts" || ext === ".mts" || ext === ".cts" || ext === ".tsx") {
+        // If the enclosing package is ESM, use dynamic import instead of require.
+        const pkgJsonPath = findNearestPackageJson(resolvedPath);
+        const pkgType = pkgJsonPath ? readPackageType(pkgJsonPath) : undefined;
+        const isEsmPkg = pkgType === "module";
+        if (isEsmPkg) {
+            const compiledHref = await transpileTsModuleToTemp(resolvedPath);
+            const imported = (await import(compiledHref));
+            const config = imported?.default ?? imported?.config ?? imported ?? {};
+            cleanupTempModule(compiledHref);
+            return { path: resolvedPath, config };
+        }
+        const previous = process.env.TS_NODE_COMPILER_OPTIONS;
+        // register ts-node on demand so TypeScript configs can be required
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require("ts-node/register/transpile-only");
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const required = require(resolvedPath);
+            const config = required?.default ?? required?.config ?? required ?? {};
+            return { path: resolvedPath, config };
+        }
+        finally {
+            if (previous === undefined) {
+                delete process.env.TS_NODE_COMPILER_OPTIONS;
+            }
+            else {
+                process.env.TS_NODE_COMPILER_OPTIONS = previous;
+            }
+        }
+    }
+    const imported = (await import(pathToFileURL(resolvedPath).href));
+    const config = imported?.default ?? imported?.config ?? imported ?? {};
+    return { path: resolvedPath, config };
+}
+function resolvePaths(cfgPath, config) {
+    if (!config.entry) {
+        throw new Error("cms0: config.entry is required");
+    }
+    const baseDir = path.dirname(cfgPath);
+    const entryFile = path.resolve(baseDir, config.entry);
+    const tsconfigPath = config.tsconfig
+        ? path.resolve(baseDir, config.tsconfig)
+        : undefined;
+    const apiBaseUrl = config.api?.baseUrl;
+    const apiKey = config.api?.key;
+    return {
+        configPath: cfgPath,
+        entryFile,
+        tsconfigPath,
+        apiBaseUrl,
+        apiKey,
+    };
+}
+function findTsConfig(entryFile) {
+    let dir = path.dirname(path.resolve(entryFile));
+    while (true) {
+        const candidate = path.join(dir, "tsconfig.json");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+async function transpileTsModuleToTemp(tsPath) {
+    const ts = await import("typescript");
+    const source = fs.readFileSync(tsPath, "utf8");
+    const transpiled = ts.transpileModule(source, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2022,
+            esModuleInterop: true,
+        },
+        fileName: tsPath,
+    });
+    const hash = crypto
+        .createHash("sha1")
+        .update(tsPath + source + Date.now().toString())
+        .digest("hex");
+    const outFile = path.join(path.dirname(tsPath), `.cms0-config.${hash}.mjs`);
+    fs.writeFileSync(outFile, transpiled.outputText, "utf8");
+    return pathToFileURL(outFile).href;
+}
+function cleanupTempModule(tempHref) {
+    try {
+        const filePath = fileURLToPath(tempHref);
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // ignore cleanup failures
+    }
+}
+export { DEFAULT_CONFIG_BASENAMES, findConfigPath, loadUserConfig, resolvePaths, findTsConfig, };

package/dist/esm/libs/cli/descriptor-builder-alt.js

@@ -0,0 +1,216 @@
+// Fresh descriptor builder using tree-based traversal from cms0<T>.
+import fs from "fs";
+import path from "path";
+import { Project, SyntaxKind, } from "ts-morph";
+import { findTsConfig } from "./config-loader.js";
+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 collectModelNames(sourceFiles) {
+    const names = new Set();
+    sourceFiles.forEach((sf) => {
+        sf.getTypeAliases().forEach((alias) => {
+            if (!alias.hasExportKeyword() && !alias.isDefaultExport())
+                return;
+            if (alias.getType().isObject())
+                names.add(alias.getName());
+        });
+        sf.getInterfaces().forEach((iface) => {
+            if (!iface.hasExportKeyword() && !iface.isDefaultExport())
+                return;
+            if (iface.getType().isObject())
+                names.add(iface.getName());
+        });
+    });
+    return names;
+}
+function collectReferencedModelNames(type, names, visited, ctx) {
+    const { base } = unwrapOptional(type);
+    const key = `${ctx}:${base.getText()}`;
+    if (visited.has(key))
+        return;
+    visited.add(key);
+    if (base.isUnion()) {
+        base.getUnionTypes().forEach((t, idx) => collectReferencedModelNames(t, names, visited, `${ctx}|${idx}`));
+        return;
+    }
+    if (base.isArray()) {
+        const elem = base.getArrayElementTypeOrThrow();
+        collectReferencedModelNames(elem, names, visited, `${ctx}[]`);
+        return;
+    }
+    const aliasSymbol = base.getAliasSymbol();
+    const symbol = base.getSymbol();
+    const name = aliasSymbol?.getName() ?? symbol?.getName();
+    if (name && base.isObject()) {
+        names.add(name);
+    }
+    if (base.isObject()) {
+        base.getProperties().forEach((prop) => {
+            const decl = prop.getDeclarations()[0];
+            if (!decl)
+                return;
+            collectReferencedModelNames(decl.getType(), names, visited, `${ctx}.${prop.getName()}`);
+        });
+    }
+}
+function buildProperties(type, modelNames, warnings, ctx) {
+    const props = {};
+    type.getProperties().forEach((prop) => {
+        const decl = prop.getDeclarations()[0];
+        if (!decl)
+            return;
+        const analyzed = unwrapOptional(decl.getType());
+        props[prop.getName()] = descriptorFromType(analyzed.base, modelNames, warnings, `${ctx}.${prop.getName()}`, { optional: prop.isOptional() || analyzed.optional, nullable: analyzed.nullable });
+    });
+    return props;
+}
+function descriptorFromType(type, modelNames, 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 {
+            type: "array",
+            items: descriptorFromType(elem, modelNames, warnings, `${ctx}[]`),
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    const aliasSymbol = base.getAliasSymbol();
+    const symbol = base.getSymbol();
+    const name = aliasSymbol?.getName() ?? symbol?.getName();
+    if (name && modelNames.has(name)) {
+        return { kind: "modelRef", model: name, optional: isOptional, nullable: isNullable };
+    }
+    if (base.isObject()) {
+        return {
+            type: "object",
+            properties: buildProperties(base, modelNames, warnings, ctx),
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    warnings.add(`cms0: unsupported type at ${ctx}; falling back to string`);
+    return { kind: "primitive", type: "string", optional: isOptional, nullable: isNullable };
+}
+function collectModels(sourceFiles, modelNames, modelMap, warnings) {
+    const handleShape = (name, type, ctx) => {
+        if (modelMap[name])
+            return;
+        if (!modelNames.has(name))
+            return;
+        if (!type.isObject())
+            return;
+        modelMap[name] = { kind: "model", properties: buildProperties(type, modelNames, warnings, ctx) };
+    };
+    sourceFiles.forEach((sf) => {
+        sf.getTypeAliases().forEach((alias) => {
+            if (!alias.hasExportKeyword() && !alias.isDefaultExport())
+                return;
+            handleShape(alias.getName(), alias.getType(), `model ${alias.getName()}`);
+        });
+        sf.getInterfaces().forEach((iface) => {
+            if (!iface.hasExportKeyword() && !iface.isDefaultExport())
+                return;
+            handleShape(iface.getName(), iface.getType(), `model ${iface.getName()}`);
+        });
+    });
+}
+function findRootType(sourceFiles) {
+    for (const sf of sourceFiles) {
+        const invoc = sf
+            ?.getDescendantsOfKind(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 buildDescriptorAlt(resolved) {
+    const tsconfig = resolved.tsconfigPath ?? findTsConfig(resolved.entryFile);
+    const project = tsconfig ? new Project({ tsConfigFilePath: tsconfig }) : new Project();
+    const warnings = new Set();
+    if (!project.getSourceFile(resolved.entryFile) && fs.existsSync(resolved.entryFile)) {
+        project.addSourceFileAtPath(resolved.entryFile);
+    }
+    const sourceFiles = project.getSourceFiles().filter((sf) => {
+        const filePath = path.resolve(sf.getFilePath());
+        if (filePath.includes("node_modules"))
+            return false;
+        if (filePath.endsWith(".d.ts"))
+            return false;
+        const rel = path.relative(path.dirname(resolved.entryFile), filePath);
+        return rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+    });
+    const rootType = findRootType(sourceFiles);
+    if (!rootType)
+        throw new Error("Could not locate cms0<T>() invocation in project sources.");
+    // Restrict models to only those referenced by the root type tree and exported in scope.
+    const exportedModelNames = collectModelNames(sourceFiles);
+    const referencedModelNames = new Set();
+    collectReferencedModelNames(rootType, referencedModelNames, new Set(), "root");
+    const modelNames = new Set(Array.from(referencedModelNames).filter((n) => exportedModelNames.has(n)));
+    const modelMap = {};
+    collectModels(sourceFiles, modelNames, modelMap, warnings);
+    const roots = {};
+    for (const prop of rootType.getProperties()) {
+        const name = prop.getName();
+        const decl = prop.getDeclarations()[0];
+        if (!decl)
+            continue;
+        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 = descriptorFromType(elem, modelNames, warnings, `root ${name}[]`, { optional: false, nullable: false });
+            roots[name] = {
+                type: "array",
+                items: itemDesc,
+                optional: propOptional,
+                nullable: propNullable,
+            };
+            continue;
+        }
+        const fieldDesc = descriptorFromType(propType, modelNames, warnings, `root ${name}`, { optional: propOptional, nullable: propNullable });
+        roots[name] = fieldDesc;
+    }
+    if (warnings.size)
+        warnings.forEach((w) => console.warn(w));
+    return { models: modelMap, roots };
+}
+export { buildDescriptorAlt };

package/dist/esm/libs/cli/descriptor-builder.js

@@ -0,0 +1,227 @@
+// Build a schema descriptor by inspecting user types with ts-morph.
+import fs from "fs";
+import path from "path";
+import { Project, SyntaxKind, } from "ts-morph";
+import { findTsConfig } from "./config-loader.js";
+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(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 ?? findTsConfig(resolved.entryFile);
+    const project = tsconfig
+        ? new Project({ tsConfigFilePath: tsconfig })
+        : new Project();
+    const warnings = new Set();
+    const entryDir = path.dirname(path.resolve(resolved.entryFile));
+    if (!project.getSourceFile(resolved.entryFile) &&
+        fs.existsSync(resolved.entryFile)) {
+        project.addSourceFileAtPath(resolved.entryFile);
+    }
+    const sourceFiles = project.getSourceFiles().filter((sf) => {
+        const filePath = path.resolve(sf.getFilePath());
+        const rel = path.relative(entryDir, filePath);
+        return rel && !rel.startsWith("..") && !path.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 };
+}
+export { buildDescriptor };

package/dist/esm/libs/cli/descriptor-writer.js

@@ -0,0 +1,18 @@
+import fs from "fs";
+import path from "path";
+function writeDescriptorFile(descriptor, outputPath) {
+    const output = `// Auto-generated schema descriptor\nexport const schemaDescriptor = ${JSON.stringify(descriptor, null, 2)} as const;\n`;
+    try {
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.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;
+        }
+    }
+}
+export { writeDescriptorFile };

package/dist/esm/libs/cli/index.js

@@ -0,0 +1,4 @@
+// Public surface for cms0 CLI utilities.
+export { buildOnce } from "./build.js";
+export { startWatcher } from "./watcher.js";
+export { runFromCli } from "./cli.js";

package/dist/esm/libs/cli/paths.js

@@ -0,0 +1,21 @@
+// Path utilities for locating package-relative outputs.
+import path from "path";
+import { fileURLToPath } from "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.dirname(fileURLToPath(importMetaUrl))
+        : process.cwd();
+const packageRoot = path.resolve(here, "../../..");
+const descriptorOutPath = path.resolve(packageRoot, "src/generated/schema-descriptor.ts");
+export { descriptorOutPath, packageRoot };