@cms0/cms0 0.0.1

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFromCli = runFromCli;
+// CLI entry point: parse arguments, load config, and trigger build/watch modes.
+const url_1 = require("url");
+const build_js_1 = require("./build.cjs");
+const config_loader_js_1 = require("./config-loader.cjs");
+const watcher_js_1 = require("./watcher.cjs");
+async function runFromCli() {
+    const args = process.argv.slice(2);
+    let mode = "build";
+    let configArg;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "watch" || arg === "build" || arg === "dev") {
+            mode = arg;
+        }
+        else if (arg === "--config") {
+            configArg = args[i + 1];
+            i++;
+        }
+        else if (arg && arg.startsWith("--config=")) {
+            configArg = arg.split("=")[1];
+        }
+    }
+    const loaded = await (0, config_loader_js_1.loadUserConfig)(configArg);
+    if (!loaded)
+        return;
+    const resolved = (0, config_loader_js_1.resolvePaths)(loaded.path, loaded.config);
+    console.log("resolved: ", resolved);
+    if (mode === "watch") {
+        (0, watcher_js_1.startWatcher)(resolved);
+        return;
+    }
+    if (mode === "dev") {
+        (0, watcher_js_1.startWatcher)(resolved);
+        return;
+    }
+    (0, build_js_1.buildOnce)(resolved);
+}
+// ESM/CJS-safe main check without import.meta syntax in the source so CJS builds succeed.
+const isDirectRun = (() => {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        return false;
+    if (typeof module !== "undefined" && typeof require !== "undefined") {
+        if (require.main === module)
+            return true;
+    }
+    // Use Function to access import.meta.url only when supported to avoid CJS parse errors.
+    const metaUrl = (() => {
+        try {
+            // eslint-disable-next-line no-new-func
+            return Function("return import.meta.url")();
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    return metaUrl ? metaUrl === (0, url_1.pathToFileURL)(argv1).href : false;
+})();
+if (isDirectRun) {
+    runFromCli();
+}

package/dist/cjs/libs/cli/config-loader.cjs

@@ -0,0 +1,211 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG_BASENAMES = void 0;
+exports.findConfigPath = findConfigPath;
+exports.loadUserConfig = loadUserConfig;
+exports.resolvePaths = resolvePaths;
+exports.findTsConfig = findTsConfig;
+// Load cms0.config files and resolve relevant paths for the CLI.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const crypto_1 = __importDefault(require("crypto"));
+const DEFAULT_CONFIG_BASENAMES = [
+    "cms0.config.ts",
+    "cms0.config.js",
+    "cms0.config.mjs",
+    "cms0.config.cjs",
+    "cms0.config.json",
+];
+exports.DEFAULT_CONFIG_BASENAMES = DEFAULT_CONFIG_BASENAMES;
+function findConfigPath(provided) {
+    if (provided) {
+        const resolved = path_1.default.isAbsolute(provided)
+            ? provided
+            : path_1.default.resolve(process.cwd(), provided);
+        return fs_1.default.existsSync(resolved) ? resolved : undefined;
+    }
+    let dir = process.cwd();
+    while (true) {
+        for (const name of DEFAULT_CONFIG_BASENAMES) {
+            const candidate = path_1.default.join(dir, name);
+            if (fs_1.default.existsSync(candidate))
+                return candidate;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function findNearestPackageJson(startPath) {
+    let dir = path_1.default.dirname(startPath);
+    while (true) {
+        const candidate = path_1.default.join(dir, "package.json");
+        if (fs_1.default.existsSync(candidate))
+            return candidate;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function readPackageType(pkgJsonPath) {
+    try {
+        const raw = fs_1.default.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_1.default.extname(resolvedPath).toLowerCase();
+    if (ext === ".json") {
+        const json = fs_1.default.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 Promise.resolve(`${compiledHref}`).then(s => __importStar(require(s))));
+            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 Promise.resolve(`${(0, url_1.pathToFileURL)(resolvedPath).href}`).then(s => __importStar(require(s))));
+    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_1.default.dirname(cfgPath);
+    const entryFile = path_1.default.resolve(baseDir, config.entry);
+    const tsconfigPath = config.tsconfig
+        ? path_1.default.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_1.default.dirname(path_1.default.resolve(entryFile));
+    while (true) {
+        const candidate = path_1.default.join(dir, "tsconfig.json");
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+async function transpileTsModuleToTemp(tsPath) {
+    const ts = await Promise.resolve().then(() => __importStar(require("typescript")));
+    const source = fs_1.default.readFileSync(tsPath, "utf8");
+    const transpiled = ts.transpileModule(source, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2022,
+            esModuleInterop: true,
+        },
+        fileName: tsPath,
+    });
+    const hash = crypto_1.default
+        .createHash("sha1")
+        .update(tsPath + source + Date.now().toString())
+        .digest("hex");
+    const outFile = path_1.default.join(path_1.default.dirname(tsPath), `.cms0-config.${hash}.mjs`);
+    fs_1.default.writeFileSync(outFile, transpiled.outputText, "utf8");
+    return (0, url_1.pathToFileURL)(outFile).href;
+}
+function cleanupTempModule(tempHref) {
+    try {
+        const filePath = (0, url_1.fileURLToPath)(tempHref);
+        fs_1.default.unlinkSync(filePath);
+    }
+    catch {
+        // ignore cleanup failures
+    }
+}

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

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDescriptorAlt = buildDescriptorAlt;
+// Fresh descriptor builder using tree-based traversal from cms0<T>.
+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 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(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 buildDescriptorAlt(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();
+    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());
+        if (filePath.includes("node_modules"))
+            return false;
+        if (filePath.endsWith(".d.ts"))
+            return false;
+        const rel = path_1.default.relative(path_1.default.dirname(resolved.entryFile), filePath);
+        return rel && !rel.startsWith("..") && !path_1.default.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 };
+}