@atmyapp/cli 0.0.4 → 0.0.7

package/dist/cli/utils/collection-transformer.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from "../logger";
+interface JsonSchema {
+    [key: string]: any;
+}
+export declare function isAmaCollectionStructure(structure: unknown): boolean;
+export declare function convertAmaCollectionStructure(path: string, structure: JsonSchema, logger: Logger): JsonSchema | null;
+export {};

package/dist/cli/utils/collection-transformer.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAmaCollectionStructure = isAmaCollectionStructure;
+exports.convertAmaCollectionStructure = convertAmaCollectionStructure;
+const RESERVED_FIELD_NAMES = new Set(["id", "created_at"]);
+const PRIMITIVE_TYPES = new Set(["string", "number", "boolean", "null"]);
+const SUPPORTED_TYPES = new Set([...PRIMITIVE_TYPES, "array", "object"]);
+const AMA_ASSET_TYPE_MAP = {
+    AmaImage: { format: "image" },
+    AmaFile: { format: "file" },
+    AmaIcon: { format: "image", semanticType: "image" },
+};
+function detectAmaAssetField(schema) {
+    var _a, _b, _c, _d, _e, _f;
+    const structureProperties = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a.structure) === null || _b === void 0 ? void 0 : _b.properties;
+    const amaType = (_c = structureProperties === null || structureProperties === void 0 ? void 0 : structureProperties.__amatype) === null || _c === void 0 ? void 0 : _c.const;
+    if (typeof amaType !== "string") {
+        return null;
+    }
+    const assetMapping = AMA_ASSET_TYPE_MAP[amaType];
+    if (!assetMapping) {
+        return null;
+    }
+    let imageOptions;
+    const configSchema = (_d = structureProperties === null || structureProperties === void 0 ? void 0 : structureProperties.__config) === null || _d === void 0 ? void 0 : _d.properties;
+    if (configSchema && configSchema.imageOptions) {
+        const optionsSchema = configSchema.imageOptions;
+        imageOptions = (_f = (_e = optionsSchema.const) !== null && _e !== void 0 ? _e : optionsSchema.default) !== null && _f !== void 0 ? _f : undefined;
+    }
+    return Object.assign({ format: assetMapping.format, semanticType: assetMapping.semanticType }, (imageOptions ? { imageOptions } : {}));
+}
+function ensureDescription(description, fallback) {
+    if (typeof description === "string" && description.trim().length > 0) {
+        return description.trim();
+    }
+    return fallback;
+}
+function normalizeType(type) {
+    if (typeof type === "string") {
+        return type;
+    }
+    if (Array.isArray(type)) {
+        const withoutNull = type.filter((value) => value !== "null");
+        if (withoutNull.length === 1) {
+            return withoutNull[0];
+        }
+        if (withoutNull.length === 0 && type.includes("null")) {
+            return "null";
+        }
+    }
+    return null;
+}
+function inferType(schema) {
+    let type = normalizeType(schema.type);
+    if (!type && Array.isArray(schema.enum) && schema.enum.length > 0) {
+        const enumTypes = new Set(schema.enum.map((value) => typeof value));
+        if (enumTypes.size === 1) {
+            type = enumTypes.has("string")
+                ? "string"
+                : enumTypes.has("number")
+                    ? "number"
+                    : enumTypes.has("boolean")
+                        ? "boolean"
+                        : null;
+        }
+    }
+    if (!type) {
+        switch (typeof schema.const) {
+            case "string":
+                type = "string";
+                break;
+            case "number":
+                type = "number";
+                break;
+            case "boolean":
+                type = "boolean";
+                break;
+            default:
+                break;
+        }
+    }
+    return type;
+}
+function copyProperties(target, source, keys) {
+    keys.forEach((key) => {
+        if (key in source) {
+            target[key] = source[key];
+        }
+    });
+}
+function convertArrayItems(schema, fieldName, logger, breadcrumb) {
+    if (!schema.items) {
+        logger.error(`Collection conversion failed for field "${breadcrumb}": array items schema is missing.`);
+        return null;
+    }
+    return convertField(schema.items, fieldName, logger, `${breadcrumb}[]`);
+}
+function convertObjectProperties(schema, logger, breadcrumb) {
+    const rawProperties = schema.properties;
+    const converted = {};
+    if (!rawProperties || typeof rawProperties !== "object") {
+        return { properties: converted };
+    }
+    for (const [childName, childSchema] of Object.entries(rawProperties)) {
+        const childBreadcrumb = `${breadcrumb}.${childName}`;
+        const convertedChild = convertField(childSchema, childName, logger, childBreadcrumb);
+        if (!convertedChild) {
+            logger.error(`Collection conversion failed for field "${childBreadcrumb}": unsupported schema.`);
+            return null;
+        }
+        converted[childName] = convertedChild;
+    }
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((value) => typeof value === "string")
+        : undefined;
+    return { properties: converted, required };
+}
+function convertField(schema, fieldName, logger, breadcrumb) {
+    if (!schema || typeof schema !== "object") {
+        logger.error(`Collection conversion failed for field "${breadcrumb}": schema is not an object.`);
+        return null;
+    }
+    const amaAsset = detectAmaAssetField(schema);
+    if (amaAsset) {
+        const description = ensureDescription(schema.description, `Generated description for ${breadcrumb}`);
+        const base = {
+            type: "string",
+            description,
+            format: amaAsset.format,
+        };
+        if (amaAsset.semanticType) {
+            base.semanticType = amaAsset.semanticType;
+        }
+        if (amaAsset.imageOptions) {
+            base.imageOptions = amaAsset.imageOptions;
+        }
+        return base;
+    }
+    let type = inferType(schema);
+    if (!type) {
+        logger.error(`Collection conversion failed for field "${breadcrumb}": could not determine field type.`);
+        return null;
+    }
+    if (type === "integer") {
+        type = "number";
+    }
+    if (!SUPPORTED_TYPES.has(type)) {
+        logger.error(`Collection conversion failed for field "${breadcrumb}": unsupported field type "${type}".`);
+        return null;
+    }
+    const description = ensureDescription(schema.description, `Generated description for ${breadcrumb}`);
+    const base = { type, description };
+    if (PRIMITIVE_TYPES.has(type)) {
+        copyProperties(base, schema, [
+            "enum",
+            "default",
+            "format",
+            "semanticType",
+            "storeInBlob",
+            "imageOptions",
+            "maxLength",
+            "minLength",
+            "pattern",
+            "minimum",
+            "maximum",
+            "multipleOf",
+        ]);
+        return base;
+    }
+    if (type === "array") {
+        const items = convertArrayItems(schema, fieldName, logger, breadcrumb);
+        if (!items) {
+            return null;
+        }
+        base.items = items;
+        copyProperties(base, schema, ["minItems", "maxItems", "uniqueItems", "default"]);
+        return base;
+    }
+    // Object type
+    const converted = convertObjectProperties(schema, logger, breadcrumb);
+    if (!converted) {
+        return null;
+    }
+    if (Object.keys(converted.properties).length > 0) {
+        base.properties = converted.properties;
+    }
+    if (converted.required && converted.required.length > 0) {
+        base.required = converted.required;
+    }
+    copyProperties(base, schema, ["default"]);
+    return base;
+}
+function extractIndexes(configSchema) {
+    var _a, _b;
+    const indexedColumnsSchema = (_a = configSchema === null || configSchema === void 0 ? void 0 : configSchema.properties) === null || _a === void 0 ? void 0 : _a.indexedColumns;
+    if (!indexedColumnsSchema) {
+        return undefined;
+    }
+    const value = (_b = indexedColumnsSchema.const) !== null && _b !== void 0 ? _b : indexedColumnsSchema.default;
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const indexes = value.filter((entry) => typeof entry === "string");
+    if (indexes.length === 0) {
+        return undefined;
+    }
+    return indexes.slice(0, 10);
+}
+function isAmaCollectionStructure(structure) {
+    var _a;
+    return Boolean(structure &&
+        typeof structure === "object" &&
+        ((_a = structure.properties) === null || _a === void 0 ? void 0 : _a.__rowType));
+}
+function convertAmaCollectionStructure(path, structure, logger) {
+    var _a, _b;
+    if (!isAmaCollectionStructure(structure)) {
+        return null;
+    }
+    const rowTypeSchema = (_a = structure.properties) === null || _a === void 0 ? void 0 : _a.__rowType;
+    if (!rowTypeSchema || typeof rowTypeSchema !== "object") {
+        logger.error(`Collection conversion failed for "${path}": missing __rowType definition.`);
+        return null;
+    }
+    const rowTypeType = inferType(rowTypeSchema);
+    if (rowTypeType !== "object") {
+        logger.error(`Collection conversion failed for "${path}": __rowType is not an object.`);
+        return null;
+    }
+    const rawFields = rowTypeSchema.properties;
+    if (!rawFields || typeof rawFields !== "object") {
+        logger.error(`Collection conversion failed for "${path}": __rowType has no properties.`);
+        return null;
+    }
+    const properties = {};
+    for (const [fieldName, fieldSchema] of Object.entries(rawFields)) {
+        if (RESERVED_FIELD_NAMES.has(fieldName)) {
+            logger.error(`Collection conversion failed for "${path}": field "${fieldName}" is reserved.`);
+            return null;
+        }
+        const converted = convertField(fieldSchema, fieldName, logger, `${path}.${fieldName}`);
+        if (!converted) {
+            return null;
+        }
+        properties[fieldName] = converted;
+    }
+    const required = Array.isArray(rowTypeSchema.required)
+        ? rowTypeSchema.required.filter((value) => typeof value === "string")
+        : [];
+    const description = ensureDescription(structure.description, `Generated collection for ${path}`);
+    const indexes = extractIndexes((_b = structure.properties) === null || _b === void 0 ? void 0 : _b.__config);
+    const collectionStructure = {
+        description,
+        properties,
+    };
+    if (required.length > 0) {
+        collectionStructure.required = required;
+    }
+    if (indexes && indexes.length > 0) {
+        collectionStructure.indexes = indexes;
+    }
+    return collectionStructure;
+}

package/dist/cli/utils/content-processor.js

@@ -18,6 +18,9 @@ function determineContentType(content) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     // Extract file extension
     const fileExt = (_a = content.path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (content.type === "collection") {
+        return "collection";
+    }
     // Check for event types - support both custom events and basic events
     if (((_b = content.structure) === null || _b === void 0 ? void 0 : _b.type) === "event" ||
         ((_c = content.structure) === null || _c === void 0 ? void 0 : _c.type) === "basic_event" ||

package/dist/cli/utils/definition-processor.d.ts

@@ -47,6 +47,7 @@ export declare const definitionPipeline: DefinitionProcessingPipeline;
 export declare const builtInProcessors: {
     typeDetector: DefinitionProcessor;
     pathNormalizer: DefinitionProcessor;
+    collectionStructureConverter: DefinitionProcessor;
 };
 export declare const builtInValidators: {
     pathValidator: ValidationRule;

package/dist/cli/utils/definition-processor.js

@@ -4,6 +4,7 @@ exports.builtInOutputTransformers = exports.builtInValidators = exports.builtInP
 exports.registerBuiltInProcessors = registerBuiltInProcessors;
 exports.registerBuiltInValidators = registerBuiltInValidators;
 exports.registerBuiltInOutputTransformers = registerBuiltInOutputTransformers;
+const collection_transformer_1 = require("./collection-transformer");
 // Registry for processors, transformers, and validators
 class DefinitionProcessingPipeline {
     constructor() {
@@ -135,6 +136,10 @@ exports.builtInProcessors = {
         process: (content, context) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             const { logger } = context;
+            if (content.type) {
+                logger.verbose_log(`Preserving pre-detected type "${content.type}" for ${content.path}`);
+                return content;
+            }
             // Extract file extension
             const fileExt = (_a = content.path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
             // Check for event types first
@@ -181,6 +186,21 @@ exports.builtInProcessors = {
             return content;
         },
     },
+    collectionStructureConverter: {
+        name: "collection-structure-converter",
+        process: (content, context) => {
+            const { logger } = context;
+            if (!(0, collection_transformer_1.isAmaCollectionStructure)(content.structure)) {
+                return content;
+            }
+            const converted = (0, collection_transformer_1.convertAmaCollectionStructure)(content.path, content.structure, logger);
+            if (!converted) {
+                logger.warn(`Skipping definition "${content.path}" due to collection conversion errors.`);
+                return null;
+            }
+            return Object.assign(Object.assign({}, content), { type: "collection", structure: converted });
+        },
+    },
 };
 // Built-in validators
 exports.builtInValidators = {
@@ -240,6 +260,7 @@ exports.builtInOutputTransformers = {
 // Helper functions to register built-in components
 function registerBuiltInProcessors() {
     exports.definitionPipeline.addProcessor(exports.builtInProcessors.pathNormalizer);
+    exports.definitionPipeline.addProcessor(exports.builtInProcessors.collectionStructureConverter);
     exports.definitionPipeline.addProcessor(exports.builtInProcessors.typeDetector);
 }
 function registerBuiltInValidators() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atmyapp/cli",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -28,7 +28,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@atmyapp/core": "^0.0.5",
+    "@atmyapp/core": "^0.0.6",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",