@cms0/cms0 0.0.1 → 0.0.4

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

@@ -9,6 +9,22 @@ 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");
+const registry_js_1 = require("../../custom-types/registry.cjs");
+function resolveCustomTypeName(type) {
+    const aliasSymbol = type.getAliasSymbol();
+    const symbol = type.getSymbol();
+    const name = aliasSymbol?.getName() ?? symbol?.getName();
+    if (name && registry_js_1.customTypeNames.has(name)) {
+        return name;
+    }
+    const text = type.getText();
+    for (const customName of registry_js_1.customTypeNames) {
+        if (text === customName || text.endsWith(`.${customName}`)) {
+            return customName;
+        }
+    }
+    return undefined;
+}
 function unwrapOptional(type) {
     let optional = false;
     let nullable = false;
@@ -31,6 +47,14 @@ function unwrapOptional(type) {
     }
     return { base: type, optional, nullable };
 }
+function applyOptionalityToDescriptor(desc, optional, nullable) {
+    const clone = JSON.parse(JSON.stringify(desc));
+    if (optional)
+        clone.optional = true;
+    if (nullable)
+        clone.nullable = true;
+    return clone;
+}
 function collectModelNames(sourceFiles) {
     const names = new Set();
     sourceFiles.forEach((sf) => {
@@ -56,7 +80,9 @@ function collectReferencedModelNames(type, names, visited, ctx) {
         return;
     visited.add(key);
     if (base.isUnion()) {
-        base.getUnionTypes().forEach((t, idx) => collectReferencedModelNames(t, names, visited, `${ctx}|${idx}`));
+        base
+            .getUnionTypes()
+            .forEach((t, idx) => collectReferencedModelNames(t, names, visited, `${ctx}|${idx}`));
         return;
     }
     if (base.isArray()) {
@@ -67,7 +93,11 @@ function collectReferencedModelNames(type, names, visited, ctx) {
     const aliasSymbol = base.getAliasSymbol();
     const symbol = base.getSymbol();
     const name = aliasSymbol?.getName() ?? symbol?.getName();
-    if (name && base.isObject()) {
+    const customName = resolveCustomTypeName(base);
+    if (customName) {
+        names.add(customName);
+    }
+    else if (name && base.isObject()) {
         names.add(name);
     }
     if (base.isObject()) {
@@ -86,7 +116,10 @@ function buildProperties(type, modelNames, warnings, ctx) {
         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 });
+        props[prop.getName()] = descriptorFromType(analyzed.base, modelNames, warnings, `${ctx}.${prop.getName()}`, {
+            optional: prop.isOptional() || analyzed.optional,
+            nullable: analyzed.nullable,
+        });
     });
     return props;
 }
@@ -95,13 +128,35 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
     const isOptional = !!opts?.optional || optional;
     const isNullable = !!opts?.nullable || nullable;
     if (base.isString()) {
-        return { kind: "primitive", type: "string", optional: isOptional, nullable: isNullable };
+        return {
+            kind: "primitive",
+            type: "string",
+            optional: isOptional,
+            nullable: isNullable,
+        };
     }
     if (base.isNumber()) {
-        return { kind: "primitive", type: "number", optional: isOptional, nullable: isNullable };
+        return {
+            kind: "primitive",
+            type: "number",
+            optional: isOptional,
+            nullable: isNullable,
+        };
     }
     if (base.isBoolean()) {
-        return { kind: "primitive", type: "boolean", optional: isOptional, nullable: isNullable };
+        return {
+            kind: "primitive",
+            type: "boolean",
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    const customName = resolveCustomTypeName(base);
+    if (customName && registry_js_1.customInlineTypeNames.has(customName)) {
+        const inlineDescriptor = registry_js_1.customInlineDescriptors[customName];
+        if (inlineDescriptor) {
+            return applyOptionalityToDescriptor(inlineDescriptor, isOptional, isNullable);
+        }
     }
     if (base.isArray()) {
         const elem = base.getArrayElementTypeOrThrow();
@@ -115,8 +170,14 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
     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 };
+    const modelName = customName ?? name;
+    if (modelName && modelNames.has(modelName)) {
+        return {
+            kind: "modelRef",
+            model: modelName,
+            optional: isOptional,
+            nullable: isNullable,
+        };
     }
     if (base.isObject()) {
         return {
@@ -127,7 +188,12 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
         };
     }
     warnings.add(`cms0: unsupported type at ${ctx}; falling back to string`);
-    return { kind: "primitive", type: "string", optional: isOptional, nullable: isNullable };
+    return {
+        kind: "primitive",
+        type: "string",
+        optional: isOptional,
+        nullable: isNullable,
+    };
 }
 function collectModels(sourceFiles, modelNames, modelMap, warnings) {
     const handleShape = (name, type, ctx) => {
@@ -137,7 +203,10 @@ function collectModels(sourceFiles, modelNames, modelMap, warnings) {
             return;
         if (!type.isObject())
             return;
-        modelMap[name] = { kind: "model", properties: buildProperties(type, modelNames, warnings, ctx) };
+        modelMap[name] = {
+            kind: "model",
+            properties: buildProperties(type, modelNames, warnings, ctx),
+        };
     };
     sourceFiles.forEach((sf) => {
         sf.getTypeAliases().forEach((alias) => {
@@ -152,24 +221,57 @@ function collectModels(sourceFiles, modelNames, modelMap, warnings) {
         });
     });
 }
-function findRootType(sourceFiles) {
+function readCms0Options(invoc) {
+    const arg = invoc.getArguments()[0];
+    if (!arg || !ts_morph_1.Node.isObjectLiteralExpression(arg))
+        return {};
+    const options = {};
+    const localesProp = arg.getProperty("locales");
+    if (localesProp && ts_morph_1.Node.isPropertyAssignment(localesProp)) {
+        const init = localesProp.getInitializer();
+        if (init && ts_morph_1.Node.isArrayLiteralExpression(init)) {
+            const values = init
+                .getElements()
+                .map((el) => (ts_morph_1.Node.isStringLiteral(el) ? el.getLiteralValue() : null))
+                .filter((val) => Boolean(val));
+            if (values.length)
+                options.locales = values;
+        }
+    }
+    const defaultProp = arg.getProperty("defaultLocale");
+    if (defaultProp && ts_morph_1.Node.isPropertyAssignment(defaultProp)) {
+        const init = defaultProp.getInitializer();
+        if (init && ts_morph_1.Node.isStringLiteral(init)) {
+            options.defaultLocale = init.getLiteralValue();
+        }
+    }
+    return options;
+}
+function findRootInvocation(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();
+            if (typeArgs.length > 0) {
+                return {
+                    rootType: typeArgs[0].getType(),
+                    ...readCms0Options(invoc),
+                };
+            }
         }
     }
     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 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)) {
+    if (!project.getSourceFile(resolved.entryFile) &&
+        fs_1.default.existsSync(resolved.entryFile)) {
         project.addSourceFileAtPath(resolved.entryFile);
     }
     const sourceFiles = project.getSourceFiles().filter((sf) => {
@@ -181,16 +283,36 @@ function buildDescriptorAlt(resolved) {
         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)
+    const invocation = findRootInvocation(sourceFiles);
+    if (!invocation)
         throw new Error("Could not locate cms0<T>() invocation in project sources.");
+    const rootType = invocation.rootType;
     // Restrict models to only those referenced by the root type tree and exported in scope.
     const exportedModelNames = collectModelNames(sourceFiles);
+    const collisions = Array.from(registry_js_1.customTypeNames).filter((name) => exportedModelNames.has(name));
+    if (collisions.length) {
+        throw new Error(`cms0: custom type name collision: ${collisions.join(", ")}. Rename your model(s) or use a different custom type name.`);
+    }
     const referencedModelNames = new Set();
     collectReferencedModelNames(rootType, referencedModelNames, new Set(), "root");
-    const modelNames = new Set(Array.from(referencedModelNames).filter((n) => exportedModelNames.has(n)));
+    const referencedCustomTypeNames = new Set(Array.from(referencedModelNames).filter((n) => registry_js_1.customTypeNames.has(n)));
+    const referencedCustomModelNames = new Set(Array.from(referencedCustomTypeNames).filter((n) => registry_js_1.customModelTypeNames.has(n)));
+    const resolvedCustomTypeNames = (0, registry_js_1.resolveCustomTypeDependencies)(referencedCustomModelNames);
+    const modelNames = new Set([
+        ...Array.from(referencedModelNames).filter((n) => exportedModelNames.has(n)),
+        ...Array.from(resolvedCustomTypeNames),
+    ]);
     const modelMap = {};
     collectModels(sourceFiles, modelNames, modelMap, warnings);
+    resolvedCustomTypeNames.forEach((name) => {
+        if (modelMap[name]) {
+            return;
+        }
+        const descriptor = registry_js_1.customModelDescriptors[name];
+        if (descriptor) {
+            modelMap[name] = descriptor;
+        }
+    });
     const roots = {};
     for (const prop of rootType.getProperties()) {
         const name = prop.getName();
@@ -217,5 +339,16 @@ function buildDescriptorAlt(resolved) {
     }
     if (warnings.size)
         warnings.forEach((w) => console.warn(w));
-    return { models: modelMap, roots };
+    const locales = invocation.locales;
+    const defaultLocale = invocation.defaultLocale;
+    return {
+        models: modelMap,
+        roots,
+        metadata: locales || defaultLocale
+            ? {
+                locales,
+                defaultLocale,
+            }
+            : undefined,
+    };
 }

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

@@ -127,7 +127,33 @@ function collectModels(sourceFiles, modelMap, warnings) {
         });
     });
 }
-function findRootType(sourceFiles) {
+function readCms0Options(invoc) {
+    const arg = invoc.getArguments()[0];
+    if (!arg || !ts_morph_1.Node.isObjectLiteralExpression(arg))
+        return {};
+    const options = {};
+    const localesProp = arg.getProperty("locales");
+    if (localesProp && ts_morph_1.Node.isPropertyAssignment(localesProp)) {
+        const init = localesProp.getInitializer();
+        if (init && ts_morph_1.Node.isArrayLiteralExpression(init)) {
+            const values = init
+                .getElements()
+                .map((el) => (ts_morph_1.Node.isStringLiteral(el) ? el.getLiteralValue() : null))
+                .filter((val) => Boolean(val));
+            if (values.length)
+                options.locales = values;
+        }
+    }
+    const defaultProp = arg.getProperty("defaultLocale");
+    if (defaultProp && ts_morph_1.Node.isPropertyAssignment(defaultProp)) {
+        const init = defaultProp.getInitializer();
+        if (init && ts_morph_1.Node.isStringLiteral(init)) {
+            options.defaultLocale = init.getLiteralValue();
+        }
+    }
+    return options;
+}
+function findRootInvocation(sourceFiles) {
     for (const sf of sourceFiles) {
         const invoc = sf
             ?.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
@@ -135,7 +161,10 @@ function findRootType(sourceFiles) {
         if (invoc) {
             const typeArgs = invoc.getTypeArguments();
             if (typeArgs.length > 0) {
-                return typeArgs[0].getType();
+                return {
+                    rootType: typeArgs[0].getType(),
+                    ...readCms0Options(invoc),
+                };
             }
         }
     }
@@ -159,10 +188,11 @@ function buildDescriptor(resolved) {
     });
     const modelMap = {};
     collectModels(sourceFiles, modelMap, warnings);
-    const rootType = findRootType(sourceFiles);
-    if (!rootType) {
+    const invocation = findRootInvocation(sourceFiles);
+    if (!invocation) {
         throw new Error("Could not locate cms0<T>() invocation in project sources.");
     }
+    const rootType = invocation.rootType;
     const roots = {};
     for (const prop of rootType.getProperties()) {
         const name = prop.getName();
@@ -228,5 +258,16 @@ function buildDescriptor(resolved) {
     if (warnings.size) {
         warnings.forEach((w) => console.warn(w));
     }
-    return { models: modelMap, roots };
+    const locales = invocation.locales;
+    const defaultLocale = invocation.defaultLocale;
+    return {
+        models: modelMap,
+        roots,
+        metadata: locales || defaultLocale
+            ? {
+                locales,
+                defaultLocale,
+            }
+            : undefined,
+    };
 }

package/dist/esm/custom-types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/custom-types/registry.js

@@ -0,0 +1,119 @@
+const primitive = (type) => ({
+    kind: "primitive",
+    type,
+    optional: false,
+    nullable: false,
+});
+const fileFieldDescriptors = {
+    name: primitive("string"),
+    filename: primitive("string"),
+    extension: primitive("string"),
+    mimeType: primitive("string"),
+    size: primitive("number"),
+};
+const fileDescriptor = {
+    kind: "model",
+    properties: fileFieldDescriptors,
+};
+const imageDescriptor = {
+    kind: "model",
+    properties: {
+        ...fileFieldDescriptors,
+        width: primitive("number"),
+        height: primitive("number"),
+        alt: { kind: "primitive", type: "string", optional: true, nullable: false },
+    },
+};
+const videoDescriptor = {
+    kind: "model",
+    properties: {
+        ...fileFieldDescriptors,
+        width: primitive("number"),
+        height: primitive("number"),
+        length: primitive("number"),
+        alt: { kind: "primitive", type: "string", optional: true, nullable: false },
+    },
+};
+const richTextDescriptor = {
+    kind: "primitive",
+    type: "json",
+    customType: "RichText",
+};
+const localizedStringDescriptor = {
+    type: "array",
+    items: {
+        type: "object",
+        properties: {
+            locale: primitive("string"),
+            isDefault: primitive("boolean"),
+            value: primitive("string"),
+        },
+    },
+    customType: "LocalizedString",
+};
+const localizedRichTextDescriptor = {
+    type: "array",
+    items: {
+        type: "object",
+        properties: {
+            locale: primitive("string"),
+            isDefault: primitive("boolean"),
+            value: primitive("json"),
+            html: primitive("string"),
+        },
+    },
+    customType: "LocalizedRichText",
+};
+export const customModelDescriptors = {
+    File: fileDescriptor,
+    Image: imageDescriptor,
+    Video: videoDescriptor,
+};
+export const customInlineDescriptors = {
+    RichText: richTextDescriptor,
+    LocalizedString: localizedStringDescriptor,
+    LocalizedRichText: localizedRichTextDescriptor,
+};
+export const customTypeDescriptors = {
+    ...customModelDescriptors,
+    ...customInlineDescriptors,
+};
+export const customTypeNames = new Set(Object.keys(customTypeDescriptors));
+export const customModelTypeNames = new Set(Object.keys(customModelDescriptors));
+export const customInlineTypeNames = new Set(Object.keys(customInlineDescriptors));
+export function resolveCustomTypeDependencies(names) {
+    const resolved = new Set();
+    const queue = Array.from(names);
+    while (queue.length) {
+        const name = queue.shift();
+        if (!name || resolved.has(name))
+            continue;
+        const descriptor = customModelDescriptors[name];
+        if (!descriptor)
+            continue;
+        resolved.add(name);
+        const refs = new Set();
+        for (const prop of Object.values(descriptor.properties)) {
+            collectModelRefs(prop, refs);
+        }
+        refs.forEach((ref) => {
+            if (customTypeDescriptors[ref] && !resolved.has(ref)) {
+                queue.push(ref);
+            }
+        });
+    }
+    return resolved;
+}
+function collectModelRefs(desc, out) {
+    if (desc.kind === "modelRef") {
+        out.add(desc.model);
+        return;
+    }
+    if (desc.type === "array") {
+        collectModelRefs(desc.items, out);
+        return;
+    }
+    if (desc.type === "object") {
+        Object.values(desc.properties).forEach((child) => collectModelRefs(child, out));
+    }
+}