@atmyapp/cli 0.0.1

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

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtInOutputTransformers = exports.builtInValidators = exports.builtInProcessors = exports.definitionPipeline = void 0;
+exports.registerBuiltInProcessors = registerBuiltInProcessors;
+exports.registerBuiltInValidators = registerBuiltInValidators;
+exports.registerBuiltInOutputTransformers = registerBuiltInOutputTransformers;
+// Registry for processors, transformers, and validators
+class DefinitionProcessingPipeline {
+    constructor() {
+        this.processors = [];
+        this.outputTransformers = [];
+        this.validators = [];
+    }
+    // Register a definition processor
+    addProcessor(processor) {
+        this.processors.push(processor);
+    }
+    // Register an output transformer
+    addOutputTransformer(transformer) {
+        this.outputTransformers.push(transformer);
+    }
+    // Register a validation rule
+    addValidator(validator) {
+        this.validators.push(validator);
+    }
+    // Process definitions through the pipeline
+    processDefinitions(contents, config, logger) {
+        const processedContents = [];
+        const validationResults = [];
+        logger.verbose_log(`Processing ${contents.length} definitions through pipeline`);
+        contents.forEach((content, index) => {
+            const context = {
+                logger,
+                config,
+                allContents: contents,
+                currentIndex: index,
+            };
+            // Validate content
+            const validation = this.validateContent(content, context);
+            validationResults.push(validation);
+            if (!validation.isValid) {
+                logger.error(`Validation failed for ${content.path}: ${validation.errors.join(", ")}`);
+                return; // Skip processing invalid content
+            }
+            if (validation.warnings.length > 0) {
+                validation.warnings.forEach((warning) => logger.warn(`Warning for ${content.path}: ${warning}`));
+            }
+            // Process content through processors
+            let processedContent = content;
+            for (const processor of this.processors) {
+                if (processedContent === null)
+                    break;
+                logger.verbose_log(`Applying processor: ${processor.name} to ${content.path}`);
+                try {
+                    processedContent = processor.process(processedContent, context);
+                }
+                catch (error) {
+                    logger.error(`Processor ${processor.name} failed for ${content.path}:`, error);
+                    processedContent = null;
+                    break;
+                }
+            }
+            if (processedContent !== null) {
+                processedContents.push(processedContent);
+                logger.verbose_log(`Successfully processed ${content.path}`);
+            }
+        });
+        return { processedContents, validationResults };
+    }
+    // Transform the final output
+    transformOutput(output, config, logger) {
+        let transformedOutput = output;
+        const context = {
+            logger,
+            config,
+            allContents: [],
+            currentIndex: 0,
+        };
+        for (const transformer of this.outputTransformers) {
+            logger.verbose_log(`Applying output transformer: ${transformer.name}`);
+            try {
+                transformedOutput = transformer.transform(transformedOutput, context);
+            }
+            catch (error) {
+                logger.error(`Output transformer ${transformer.name} failed:`, error);
+            }
+        }
+        return transformedOutput;
+    }
+    // Validate a single content item
+    validateContent(content, context) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: [],
+        };
+        for (const validator of this.validators) {
+            try {
+                const validationResult = validator.validate(content, context);
+                if (!validationResult.isValid) {
+                    result.isValid = false;
+                }
+                result.errors.push(...validationResult.errors);
+                result.warnings.push(...validationResult.warnings);
+            }
+            catch (error) {
+                result.isValid = false;
+                result.errors.push(`Validator ${validator.name} failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        return result;
+    }
+    // Clear all registered processors, transformers, and validators
+    clear() {
+        this.processors = [];
+        this.outputTransformers = [];
+        this.validators = [];
+    }
+    // Get pipeline statistics
+    getStats() {
+        return {
+            processors: this.processors.length,
+            transformers: this.outputTransformers.length,
+            validators: this.validators.length,
+        };
+    }
+}
+// Global pipeline instance
+exports.definitionPipeline = new DefinitionProcessingPipeline();
+// Built-in processors
+exports.builtInProcessors = {
+    // Processor to determine content type
+    typeDetector: {
+        name: "type-detector",
+        process: (content, context) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const { logger } = context;
+            // Extract file extension
+            const fileExt = (_a = content.path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            // Check for event types first
+            if (((_b = content.structure) === null || _b === void 0 ? void 0 : _b.type) === "event" ||
+                ((_e = (_d = (_c = content.structure) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.type) === null || _e === void 0 ? void 0 : _e.const) === "event" ||
+                ((_f = content.structure) === null || _f === void 0 ? void 0 : _f.__amatype) === "AmaEventDef") {
+                content.type = "event";
+            }
+            else if (((_g = content.structure) === null || _g === void 0 ? void 0 : _g.__amatype) === "AmaImageDef") {
+                content.type = "image";
+            }
+            else if (((_h = content.structure) === null || _h === void 0 ? void 0 : _h.__amatype) === "AmaFileDef") {
+                content.type = "file";
+            }
+            else if (["jpg", "jpeg", "png", "gif", "svg", "webp"].includes(fileExt || "")) {
+                content.type = "image";
+            }
+            else if (["pdf", "doc", "docx", "txt", "md"].includes(fileExt || "")) {
+                content.type = "file";
+            }
+            else {
+                content.type = "jsonx";
+            }
+            logger.verbose_log(`Detected type "${content.type}" for ${content.path}`);
+            return content;
+        },
+    },
+    // Processor to normalize paths
+    pathNormalizer: {
+        name: "path-normalizer",
+        process: (content, context) => {
+            const { logger } = context;
+            // Normalize path separators
+            const normalizedPath = content.path.replace(/\\/g, "/");
+            // Remove leading slashes
+            const cleanPath = normalizedPath.replace(/^\/+/, "");
+            if (cleanPath !== content.path) {
+                logger.verbose_log(`Normalized path from "${content.path}" to "${cleanPath}"`);
+                content.path = cleanPath;
+            }
+            return content;
+        },
+    },
+};
+// Built-in validators
+exports.builtInValidators = {
+    // Validator to check if path is provided
+    pathValidator: {
+        name: "path-validator",
+        validate: (content, context) => {
+            const result = {
+                isValid: true,
+                errors: [],
+                warnings: [],
+            };
+            if (typeof content.path !== "string") {
+                result.isValid = false;
+                result.errors.push("Content must have a valid path");
+            }
+            else if (content.path.trim() === "") {
+                result.isValid = false;
+                result.errors.push("Content path cannot be empty");
+            }
+            return result;
+        },
+    },
+    // Validator to check for duplicate paths
+    duplicatePathValidator: {
+        name: "duplicate-path-validator",
+        validate: (content, context) => {
+            const result = {
+                isValid: true,
+                errors: [],
+                warnings: [],
+            };
+            const { allContents, currentIndex } = context;
+            const duplicates = allContents.filter((other, index) => index !== currentIndex && other.path === content.path);
+            if (duplicates.length > 0) {
+                result.isValid = false;
+                result.errors.push(`Duplicate path found: ${content.path}`);
+            }
+            return result;
+        },
+    },
+};
+// Built-in output transformers
+exports.builtInOutputTransformers = {
+    // Transformer to add metadata
+    metadataEnricher: {
+        name: "metadata-enricher",
+        transform: (output, context) => {
+            const { logger, config } = context;
+            // Add processing metadata
+            const metadata = Object.assign({ generatedAt: new Date().toISOString(), totalDefinitions: Object.keys(output.definitions).length, totalEvents: Object.keys(output.events || {}).length, version: "1.0.0" }, (config.metadata || {}));
+            logger.verbose_log(`Adding metadata to output: ${JSON.stringify(metadata)}`);
+            return Object.assign(Object.assign({}, output), { metadata });
+        },
+    },
+};
+// Helper functions to register built-in components
+function registerBuiltInProcessors() {
+    exports.definitionPipeline.addProcessor(exports.builtInProcessors.pathNormalizer);
+    exports.definitionPipeline.addProcessor(exports.builtInProcessors.typeDetector);
+}
+function registerBuiltInValidators() {
+    exports.definitionPipeline.addValidator(exports.builtInValidators.pathValidator);
+    exports.definitionPipeline.addValidator(exports.builtInValidators.duplicatePathValidator);
+}
+function registerBuiltInOutputTransformers() {
+    exports.definitionPipeline.addOutputTransformer(exports.builtInOutputTransformers.metadataEnricher);
+}

package/dist/cli/utils/file-operations.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from "../logger";
+import { OutputDefinition } from "../types/migrate";
+export declare function ensureAmaDirectory(logger: Logger): void;
+export declare function saveOutputToFile(output: OutputDefinition, logger: Logger): void;

package/dist/cli/utils/file-operations.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAmaDirectory = ensureAmaDirectory;
+exports.saveOutputToFile = saveOutputToFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// Ensures the .ama directory exists
+function ensureAmaDirectory(logger) {
+    const amaDir = "./.ama";
+    if (!(0, fs_1.existsSync)(amaDir)) {
+        logger.verbose_log(`Creating .ama directory at ${(0, path_1.resolve)(process.cwd(), amaDir)}`);
+        (0, fs_1.mkdirSync)(amaDir, { recursive: true });
+    }
+    else {
+        logger.verbose_log(`.ama directory already exists at ${(0, path_1.resolve)(process.cwd(), amaDir)}`);
+    }
+}
+// Saves the output definition to a local file
+function saveOutputToFile(output, logger) {
+    const outputPath = "./.ama/definitions.json";
+    logger.verbose_log(`Saving definitions to ${(0, path_1.resolve)(process.cwd(), outputPath)}`);
+    (0, fs_1.writeFileSync)(outputPath, JSON.stringify(output, null, 2));
+    logger.success(`✅ Successfully generated ${outputPath}`);
+}

package/dist/cli/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./config";
+export * from "./type-transformers";
+export * from "./schema-processor";
+export * from "./content-processor";
+export * from "./file-operations";
+export * from "./upload";
+export * from "./definition-processor";
+export * from "../types/migrate";
+export * from "../logger";

package/dist/cli/utils/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all utilities for easier imports
+__exportStar(require("./config"), exports);
+__exportStar(require("./type-transformers"), exports);
+__exportStar(require("./schema-processor"), exports);
+__exportStar(require("./content-processor"), exports);
+__exportStar(require("./file-operations"), exports);
+__exportStar(require("./upload"), exports);
+__exportStar(require("./definition-processor"), exports);
+// Re-export types and logger
+__exportStar(require("../types/migrate"), exports);
+__exportStar(require("../logger"), exports);

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

@@ -0,0 +1,7 @@
+import { Project, SourceFile, TypeAliasDeclaration } from "ts-morph";
+import { Logger } from "../logger";
+import { Content, ProcessingResult } from "../types/migrate";
+export declare function scanFiles(patterns: string[], logger: Logger): Promise<string[]>;
+export declare function createProject(files: string[], tsconfigPath: string, logger: Logger): Project;
+export declare function processAtmyappExport(atmyappType: TypeAliasDeclaration, file: SourceFile, tsconfigPath: string, logger: Logger): Content[];
+export declare function processFiles(sourceFiles: SourceFile[], tsconfigPath: string, continueOnError: boolean, logger: Logger): ProcessingResult;

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

@@ -0,0 +1,247 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanFiles = scanFiles;
+exports.createProject = createProject;
+exports.processAtmyappExport = processAtmyappExport;
+exports.processFiles = processFiles;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const ts_morph_1 = require("ts-morph");
+const ts = __importStar(require("typescript"));
+const path_1 = require("path");
+const typescript_json_schema_1 = require("typescript-json-schema");
+const fs_1 = require("fs");
+// Scans for TypeScript files based on config patterns
+function scanFiles(patterns, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.info("🔍 Scanning files...");
+        logger.verbose_log(`Using patterns: ${patterns.join(", ")}`);
+        const files = yield (0, fast_glob_1.default)(patterns, {
+            ignore: ["**/node_modules/**", "**/test/**", "**/dist/**"],
+            absolute: true,
+            cwd: process.cwd(),
+        });
+        logger.verbose_log(`Found ${files.length} files matching patterns`);
+        return files;
+    });
+}
+// Creates and configures the TypeScript project
+function createProject(files, tsconfigPath, logger) {
+    const resolvedTsConfigPath = (0, path_1.resolve)(process.cwd(), tsconfigPath);
+    if (!(0, fs_1.existsSync)(resolvedTsConfigPath)) {
+        logger.warn(`tsconfig at ${resolvedTsConfigPath} not found, using default compiler options`);
+    }
+    else {
+        logger.verbose_log(`Using tsconfig from ${resolvedTsConfigPath}`);
+    }
+    const projectOptions = {
+        tsConfigFilePath: (0, fs_1.existsSync)(resolvedTsConfigPath)
+            ? resolvedTsConfigPath
+            : undefined,
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: !(0, fs_1.existsSync)(resolvedTsConfigPath)
+            ? {
+                target: ts.ScriptTarget.ESNext,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                esModuleInterop: true,
+                jsx: ts.JsxEmit.React,
+                skipLibCheck: true,
+            }
+            : undefined,
+    };
+    logger.verbose_log("Creating ts-morph Project");
+    const project = new ts_morph_1.Project(projectOptions);
+    logger.verbose_log(`Adding ${files.length} source files to project`);
+    project.addSourceFilesAtPaths(files);
+    return project;
+}
+// Extracts individual definition types from ATMYAPP array
+function extractDefinitionTypes(atmyappType, logger) {
+    const typeNode = atmyappType.getTypeNode();
+    if (!ts_morph_1.Node.isTupleTypeNode(typeNode) && !ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        logger.warn(`ATMYAPP export should be an array/tuple type in ${atmyappType.getSourceFile().getFilePath()}`);
+        return [];
+    }
+    const elementTypes = [];
+    if (ts_morph_1.Node.isTupleTypeNode(typeNode)) {
+        // Handle tuple types: [Type1, Type2, ...]
+        typeNode.getElements().forEach((element) => {
+            const elementText = element.getText();
+            elementTypes.push(elementText);
+            logger.verbose_log(`Found definition type: ${elementText}`);
+        });
+    }
+    else if (ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        // Handle array types: Type[]
+        const elementText = typeNode.getElementTypeNode().getText();
+        elementTypes.push(elementText);
+        logger.verbose_log(`Found definition type: ${elementText}`);
+    }
+    return elementTypes;
+}
+// Processes an ATMYAPP export to extract content definitions
+function processAtmyappExport(atmyappType, file, tsconfigPath, logger) {
+    var _a, _b;
+    const contents = [];
+    logger.verbose_log(`Processing ATMYAPP export in ${file.getFilePath()}`);
+    // Extract individual definition types from the array
+    const definitionTypes = extractDefinitionTypes(atmyappType, logger);
+    if (definitionTypes.length === 0) {
+        logger.warn(`No definition types found in ATMYAPP export in ${file.getFilePath()}`);
+        return contents;
+    }
+    const resolvedTsConfigPath = (0, path_1.resolve)(process.cwd(), tsconfigPath);
+    const compilerOptions = (0, fs_1.existsSync)(resolvedTsConfigPath)
+        ? { configFile: resolvedTsConfigPath }
+        : {
+            target: ts.ScriptTarget.ES2015,
+            module: ts.ModuleKind.ESNext,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            jsx: ts.JsxEmit.Preserve,
+        };
+    const program = (0, typescript_json_schema_1.getProgramFromFiles)([file.getFilePath()], compilerOptions);
+    // Process each definition type
+    for (const definitionType of definitionTypes) {
+        try {
+            logger.verbose_log(`Generating schema for definition type: ${definitionType}`);
+            const schema = (0, typescript_json_schema_1.generateSchema)(program, definitionType, {
+                required: true,
+                noExtraProps: true,
+                aliasRef: true,
+                ref: false,
+                defaultNumberType: "number",
+                ignoreErrors: true,
+                skipLibCheck: true,
+            });
+            if (!schema) {
+                logger.warn(`Failed to generate schema for ${definitionType}`);
+                continue;
+            }
+            if (!schema.properties) {
+                logger.warn(`Invalid schema structure for ${definitionType}`);
+                continue;
+            }
+            const properties = schema.properties;
+            // Extract path from AmaContentRef structure
+            let path = null;
+            let structure = null;
+            // Look for path in different possible locations
+            if ((_a = properties.path) === null || _a === void 0 ? void 0 : _a.const) {
+                path = properties.path.const;
+            }
+            else if ((_b = properties._path) === null || _b === void 0 ? void 0 : _b.const) {
+                path = properties._path.const;
+            }
+            // Look for structure/data in different possible locations
+            if (properties.structure) {
+                structure = properties.structure;
+            }
+            else if (properties.data) {
+                structure = properties.data;
+            }
+            else if (properties._data) {
+                structure = properties._data;
+            }
+            if (!path) {
+                logger.warn(`Could not extract path from ${definitionType}`);
+                continue;
+            }
+            if (!structure) {
+                logger.warn(`Could not extract structure from ${definitionType}`);
+                continue;
+            }
+            logger.verbose_log(`Successfully extracted content: ${path}`);
+            contents.push({
+                path,
+                structure,
+            });
+        }
+        catch (err) {
+            logger.error(`Error processing definition type ${definitionType}:`, err);
+        }
+    }
+    return contents;
+}
+// Processes all files to extract contents
+function processFiles(sourceFiles, tsconfigPath, continueOnError, logger) {
+    const contents = [];
+    const errors = [];
+    let successCount = 0;
+    let failureCount = 0;
+    logger.info(`📚 Processing ${sourceFiles.length} source files...`);
+    sourceFiles.forEach((file) => {
+        logger.verbose_log(`Examining file: ${file.getFilePath()}`);
+        // Look for exported ATMYAPP type aliases
+        const atmyappExports = file.getTypeAliases().filter((alias) => {
+            const name = alias.getName();
+            const isExported = alias.isExported();
+            return name === "ATMYAPP" && isExported;
+        });
+        logger.verbose_log(`Found ${atmyappExports.length} ATMYAPP exports in ${file.getFilePath()}`);
+        atmyappExports.forEach((atmyappExport) => {
+            try {
+                const fileContents = processAtmyappExport(atmyappExport, file, tsconfigPath, logger);
+                contents.push(...fileContents);
+                successCount += fileContents.length;
+                logger.verbose_log(`Successfully processed ${fileContents.length} definitions from ATMYAPP export`);
+            }
+            catch (err) {
+                failureCount++;
+                const errorMessage = `❌ ${file.getFilePath()} - ATMYAPP export - ${err instanceof Error ? err.message : "Unknown error"}`;
+                errors.push(errorMessage);
+                logger.error(errorMessage);
+                if (!continueOnError) {
+                    throw err;
+                }
+            }
+        });
+    });
+    return { contents, errors, successCount, failureCount };
+}

package/dist/cli/utils/type-transformers.d.ts

@@ -0,0 +1,8 @@
+import { TypeTransformer } from "../types/migrate";
+/**
+ * Extracts constant values from a JSON Schema-like definition.
+ * Assumes all final fields are constants and skips any fields without const values.
+ */
+export declare function extractConstants(schema: any): any;
+export declare function registerTypeTransformer(transformer: TypeTransformer): void;
+export declare function processSpecialTypes(schema: any): any;

package/dist/cli/utils/type-transformers.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConstants = extractConstants;
+exports.registerTypeTransformer = registerTypeTransformer;
+exports.processSpecialTypes = processSpecialTypes;
+/**
+ * Extracts constant values from a JSON Schema-like definition.
+ * Assumes all final fields are constants and skips any fields without const values.
+ */
+function extractConstants(schema) {
+    // If not an object or doesn't have properties, return null
+    if (!schema || typeof schema !== "object" || !schema.properties) {
+        return null;
+    }
+    const result = {};
+    // Process each property in the schema
+    for (const [key, propDef] of Object.entries(schema.properties)) {
+        if (typeof propDef === "object" && propDef !== null) {
+            if ("const" in propDef) {
+                // If property has a const value, add it to the result
+                result[key] = propDef.const;
+            }
+            else if ("type" in propDef &&
+                propDef.type === "object" &&
+                "properties" in propDef) {
+                // If it's a nested object, recursively process it
+                const nestedResult = extractConstants(propDef);
+                if (nestedResult) {
+                    result[key] = nestedResult;
+                }
+            }
+        }
+    }
+    return Object.keys(result).length > 0 ? result : null;
+}
+// Registry of type transformers
+const typeTransformers = [
+    {
+        // Transformer for AMA image types
+        canTransform: (obj) => {
+            var _a, _b, _c, _d, _e;
+            return ((_b = (_a = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _a === void 0 ? void 0 : _a.__amatype) === null || _b === void 0 ? void 0 : _b.const) &&
+                ((_d = (_c = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _c === void 0 ? void 0 : _c.__amatype) === null || _d === void 0 ? void 0 : _d.const) === "AmaImageDef" &&
+                ((_e = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _e === void 0 ? void 0 : _e.__config);
+        },
+        transform: (obj) => {
+            return {
+                __amatype: obj.properties.__amatype.const,
+                config: extractConstants(obj.properties.__config),
+            };
+        },
+    },
+    {
+        // Transformer for AMA file types
+        canTransform: (obj) => {
+            var _a, _b, _c, _d, _e;
+            return ((_b = (_a = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _a === void 0 ? void 0 : _a.__amatype) === null || _b === void 0 ? void 0 : _b.const) &&
+                ((_d = (_c = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _c === void 0 ? void 0 : _c.__amatype) === null || _d === void 0 ? void 0 : _d.const) === "AmaFileDef" &&
+                ((_e = obj === null || obj === void 0 ? void 0 : obj.properties) === null || _e === void 0 ? void 0 : _e.__config);
+        },
+        transform: (obj) => {
+            return {
+                __amatype: obj.properties.__amatype.const,
+                config: extractConstants(obj.properties.__config),
+            };
+        },
+    },
+];
+// Register a new type transformer
+function registerTypeTransformer(transformer) {
+    typeTransformers.push(transformer);
+}
+// Recursively process the JSON structure to transform special types
+function processSpecialTypes(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    // If it's an array, process each item
+    if (Array.isArray(schema)) {
+        return schema.map(processSpecialTypes);
+    }
+    // Check if this object should be transformed
+    for (const transformer of typeTransformers) {
+        if (transformer.canTransform(schema)) {
+            return transformer.transform(schema);
+        }
+    }
+    // Process object properties recursively
+    const result = {};
+    for (const key in schema) {
+        result[key] = processSpecialTypes(schema[key]);
+    }
+    return result;
+}

package/dist/cli/utils/upload.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from "../logger";
+import { OutputDefinition } from "../types/migrate";
+export declare function uploadDefinitions(output: OutputDefinition, config: any, logger: Logger): Promise<boolean>;