@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/helpers/schema.js

@@ -0,0 +1,473 @@
+import { BaseFileManager } from './FileManager/BaseFileManager.js';
+import debug from 'debug';
+
+const logger = debug('seedSdk:helpers:schema');
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Generate filename for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilename = (name, version, schemaFileId) => {
+    const sanitizedName = sanitizeSchemaName(name);
+    return `${schemaFileId}_${sanitizedName}_v${version}.json`;
+};
+/**
+ * Get the full file path for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath = (name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const filename = getSchemaFilename(name, version, schemaFileId);
+    const workingDir = BaseFileManager.getWorkingDir();
+    return path.join(workingDir, filename);
+};
+/**
+ * Create a new schema file
+ * @param schema - The schema object to save
+ * @param schemaFileId - Schema file ID (required)
+ * @throws Error if schema already exists or if workingDir is invalid
+ */
+const createSchema = async (schema, schemaFileId) => {
+    if (!schema.name || !schema.version) {
+        throw new Error('Schema must have a name and version');
+    }
+    const filePath = getSchemaFilePath(schema.name, schema.version, schemaFileId);
+    // Check if schema already exists
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (exists) {
+        throw new Error(`Schema ${schema.name} v${schema.version} already exists`);
+    }
+    // Ensure working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(workingDir);
+    // Write schema to file
+    const content = JSON.stringify(schema, null, 2);
+    await BaseFileManager.saveFile(filePath, content);
+};
+/**
+ * Read a schema file by name and version
+ * @param name - The name of the schema
+ * @param version - The version of the schema
+ * @param schemaFileId - Schema file ID (required)
+ * @returns The schema object, or null if not found
+ */
+const readSchema = async (name, version, schemaFileId) => {
+    const filePath = getSchemaFilePath(name, version, schemaFileId);
+    const exists = await BaseFileManager.pathExists(filePath);
+    if (!exists) {
+        return null;
+    }
+    try {
+        const content = await BaseFileManager.readFileAsString(filePath);
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * List all schema files in the working directory
+ * Only returns files that are NOT already complete schema files (i.e., files without $schema field)
+ * This allows processing of minimal import files while skipping already-processed schema files
+ * @returns Array of objects containing name, version, and file path for each schema
+ */
+async function listSchemaFiles() {
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    // Check if working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    try {
+        const files = await fs.promises.readdir(workingDir);
+        const schemas = [];
+        for (const file of files) {
+            // Match filename pattern: {name}-v{version}.json
+            const match = file.match(/^(.+)-v(\d+)\.json$/);
+            if (match) {
+                const [, name, versionStr] = match;
+                const version = parseInt(versionStr, 10);
+                if (!isNaN(version)) {
+                    const filePath = path.join(workingDir, file);
+                    // Check if this file is already a complete schema file (has $schema field)
+                    // If it is, skip it since it's already been processed
+                    try {
+                        const content = await BaseFileManager.readFileAsString(filePath);
+                        const data = JSON.parse(content);
+                        // Skip files that already have $schema (complete schema format)
+                        // These are already processed and don't need to be imported again
+                        if (data.$schema) {
+                            continue;
+                        }
+                    }
+                    catch (error) {
+                        // If we can't read/parse the file, skip it
+                        continue;
+                    }
+                    schemas.push({
+                        name,
+                        version,
+                        filePath,
+                    });
+                }
+            }
+        }
+        return schemas;
+    }
+    catch (error) {
+        throw new Error(`Failed to list schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * List all complete schema files in the working directory
+ * Only returns files that are complete schema files (i.e., files with $schema field)
+ * These are already-processed schema files that need to be loaded into the model store
+ * @returns Array of objects containing name, version, and file path for each complete schema
+ */
+async function listCompleteSchemaFiles() {
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    // Check if working directory exists
+    const workingDir = BaseFileManager.getWorkingDir();
+    try {
+        // Check if directory exists before trying to read it
+        const dirExists = await BaseFileManager.pathExists(workingDir);
+        if (!dirExists) {
+            // Directory doesn't exist yet - return empty array (not an error condition)
+            logger(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
+            return [];
+        }
+        const files = await fs.promises.readdir(workingDir);
+        const schemas = [];
+        for (const file of files) {
+            // Match filename pattern: {schemaFileId}_{schemaName}_v{version}.json
+            const match = file.match(/^(.+)_(.+)_v(\d+)\.json$/);
+            if (match) {
+                const [, schemaFileId, schemaName, versionStr] = match;
+                const version = parseInt(versionStr, 10);
+                if (!isNaN(version)) {
+                    const filePath = path.join(workingDir, file);
+                    // Check if this file is a complete schema file (has $schema field)
+                    try {
+                        const content = await BaseFileManager.readFileAsString(filePath);
+                        const data = JSON.parse(content);
+                        // Only include files that have $schema (complete schema format)
+                        if (data.$schema && data.metadata?.name) {
+                            // CRITICAL: Use schemaFileId from filename (source of truth), not from JSON content
+                            // The filename pattern is {schemaFileId}_{schemaName}_v{version}.json
+                            // The JSON content's id might be out of sync, but the filename tells us what file actually exists
+                            schemas.push({
+                                name: data.metadata.name,
+                                version: data.version || version,
+                                filePath,
+                                schemaFileId: schemaFileId, // Use from filename, not data.id
+                            });
+                        }
+                    }
+                    catch (error) {
+                        // If we can't read/parse the file, skip it
+                        continue;
+                    }
+                }
+            }
+        }
+        return schemas;
+    }
+    catch (error) {
+        throw new Error(`Failed to list complete schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get the latest version number for a schema by name
+ * Only considers complete schema files (with $schema field)
+ * @param name - The name of the schema
+ * @returns The latest version number, or 0 if no schema found
+ */
+async function getLatestSchemaVersion(name) {
+    const completeSchemas = await listCompleteSchemaFiles();
+    const matchingSchemas = completeSchemas.filter((s) => s.name === name);
+    if (matchingSchemas.length === 0) {
+        return 0;
+    }
+    // Find the schema with the highest version
+    const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+    return latest.version;
+}
+/**
+ * Get only the latest version of each schema
+ * @returns Array of objects containing name, version, and file path for the latest version of each schema
+ */
+async function listLatestSchemaFiles() {
+    const completeSchemas = await listCompleteSchemaFiles();
+    // Group by schema name and keep only the latest version of each
+    const schemaMap = new Map();
+    for (const schema of completeSchemas) {
+        const existing = schemaMap.get(schema.name);
+        if (!existing || schema.version > existing.version) {
+            schemaMap.set(schema.name, schema);
+        }
+    }
+    return Array.from(schemaMap.values());
+}
+/**
+ * Unified schema loading function that queries database first, then merges with files
+ * Returns all schemas with their draft status and source information
+ * @returns Array of schema objects with metadata about their state
+ */
+async function loadAllSchemasFromDb() {
+    const { BaseDb } = await import('../db/Db/BaseDb.js');
+    const { schemas: schemasTable } = await import('../seedSchema/SchemaSchema.js');
+    const { desc } = await import('drizzle-orm');
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const result = [];
+    // STEP 1: Query all schemas from database
+    // Also do a direct SQL query to verify what's actually in the database
+    const { sql } = await import('drizzle-orm');
+    const directQuery = await db.run(sql.raw(`SELECT name, version, schema_file_id, id FROM schemas ORDER BY name, version DESC`));
+    console.log(`[loadAllSchemasFromDb] Direct SQL query result:`, directQuery.rows?.map((row) => ({ name: row[0], version: row[1], schemaFileId: row[2], id: row[3] })) || []);
+    const dbSchemas = await db
+        .select()
+        .from(schemasTable)
+        .orderBy(schemasTable.name, desc(schemasTable.version));
+    console.log(`[loadAllSchemasFromDb] Drizzle query returned ${dbSchemas.length} schemas:`, dbSchemas.map(s => ({ name: s.name, version: s.version, schemaFileId: s.schemaFileId, isDraft: s.isDraft, id: s.id })));
+    console.log(`[loadAllSchemasFromDb] Schema names in query result:`, dbSchemas.map(s => s.name));
+    const processedSchemaNames = new Set();
+    // STEP 2: Process each database schema
+    for (const dbSchema of dbSchemas) {
+        const schemaName = dbSchema.name;
+        console.log(`[loadAllSchemasFromDb] Processing schema: ${schemaName} (id: ${dbSchema.id}, isDraft: ${dbSchema.isDraft}, hasSchemaData: ${!!dbSchema.schemaData}, schemaFileId: ${dbSchema.schemaFileId})`);
+        // Skip if we've already processed a newer version of this schema
+        if (processedSchemaNames.has(schemaName)) {
+            console.log(`[loadAllSchemasFromDb] Skipping ${schemaName} - already processed`);
+            continue;
+        }
+        // If it's a draft, load from schemaData
+        if (dbSchema.isDraft === true && dbSchema.schemaData) {
+            try {
+                let schemaFile = JSON.parse(dbSchema.schemaData);
+                // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
+                // This ensures models added to the database are included even if they're not in schemaData
+                // Build merged models without mutating schemaFile (read-only approach)
+                let mergedModels = { ...(schemaFile.models || {}) };
+                if (dbSchema.id) {
+                    const { loadModelsFromDbForSchema } = await import('./db.js');
+                    const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
+                    if (Object.keys(dbModels).length > 0) {
+                        // Merge: database models take precedence for properties, but preserve schemaData models for full structure
+                        mergedModels = {
+                            ...mergedModels,
+                            ...dbModels,
+                        };
+                        // For models that exist in both, merge properties (database properties override)
+                        for (const [modelName, dbModel] of Object.entries(dbModels)) {
+                            if (mergedModels[modelName]) {
+                                // Merge properties, with database properties taking precedence
+                                mergedModels[modelName] = {
+                                    ...mergedModels[modelName],
+                                    properties: {
+                                        ...mergedModels[modelName].properties,
+                                        ...dbModel.properties,
+                                    },
+                                };
+                            }
+                        }
+                    }
+                }
+                // Create new schemaFile object with merged models (read-only approach)
+                schemaFile = {
+                    ...schemaFile,
+                    models: mergedModels,
+                };
+                result.push({
+                    schema: schemaFile,
+                    isDraft: true,
+                    source: 'db',
+                    schemaRecordId: dbSchema.id || undefined,
+                });
+                processedSchemaNames.add(schemaName);
+                continue;
+            }
+            catch (error) {
+                logger(`Error parsing schemaData for ${schemaName}:`, error);
+                // Fall through to file-based loading
+            }
+        }
+        // If it's not a draft and has schemaFileId, try to load from file
+        if (dbSchema.isDraft === false && dbSchema.schemaFileId) {
+            let completeSchemas = [];
+            try {
+                completeSchemas = await listCompleteSchemaFiles();
+            }
+            catch (error) {
+                // If we can't list schema files (e.g., directory doesn't exist yet), continue without file-based loading
+                logger(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName);
+            if (matchingSchemas.length > 0) {
+                // Find the schema with the highest version
+                const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
+                try {
+                    // Read the file directly to get SchemaFileFormat
+                    const content = await BaseFileManager.readFileAsString(latest.filePath);
+                    const schemaFile = JSON.parse(content);
+                    // Check if file is newer than DB record
+                    const fileUpdatedAt = new Date(schemaFile.metadata.updatedAt).getTime();
+                    const dbUpdatedAt = dbSchema.updatedAt || 0;
+                    // If file is newer, update DB with file content
+                    if (fileUpdatedAt > dbUpdatedAt && schemaFile.id === dbSchema.schemaFileId) {
+                        const { addSchemaToDb } = await import('./db.js');
+                        await addSchemaToDb({
+                            name: schemaName,
+                            version: schemaFile.version,
+                            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                            updatedAt: fileUpdatedAt,
+                        }, schemaFile.id, JSON.stringify(schemaFile, null, 2), false);
+                    }
+                    result.push({
+                        schema: schemaFile,
+                        isDraft: false,
+                        source: 'db+file',
+                        schemaRecordId: dbSchema.id || undefined,
+                    });
+                    processedSchemaNames.add(schemaName);
+                    continue;
+                }
+                catch (error) {
+                    logger(`Error loading schema file for ${schemaName}:`, error);
+                    // Fall through to try loading from schemaData if available
+                }
+            }
+            // If file doesn't exist but we have schemaData, use that
+            console.log(`[loadAllSchemasFromDb] ${schemaName}: file not found, checking schemaData...`);
+            if (dbSchema.schemaData) {
+                try {
+                    let schemaFile = JSON.parse(dbSchema.schemaData);
+                    // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
+                    // This ensures models added to the database are included even if they're not in schemaData
+                    // Build merged models without mutating schemaFile (read-only approach)
+                    let mergedModels = { ...(schemaFile.models || {}) };
+                    if (dbSchema.id) {
+                        const { loadModelsFromDbForSchema } = await import('./db.js');
+                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
+                        if (Object.keys(dbModels).length > 0) {
+                            // Merge: database models take precedence for properties, but preserve schemaData models for full structure
+                            mergedModels = {
+                                ...mergedModels,
+                                ...dbModels,
+                            };
+                            // For models that exist in both, merge properties (database properties override)
+                            for (const [modelName, dbModel] of Object.entries(dbModels)) {
+                                if (mergedModels[modelName]) {
+                                    // Merge properties, with database properties taking precedence
+                                    mergedModels[modelName] = {
+                                        ...mergedModels[modelName],
+                                        properties: {
+                                            ...mergedModels[modelName].properties,
+                                            ...dbModel.properties,
+                                        },
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    // Create new schemaFile object with merged models (read-only approach)
+                    schemaFile = {
+                        ...schemaFile,
+                        models: mergedModels,
+                    };
+                    console.log(`[loadAllSchemasFromDb] Adding schema from schemaData: ${schemaName} (id: ${dbSchema.id}, schemaFileId: ${dbSchema.schemaFileId})`);
+                    result.push({
+                        schema: schemaFile,
+                        isDraft: false,
+                        source: 'db',
+                        schemaRecordId: dbSchema.id || undefined,
+                    });
+                    processedSchemaNames.add(schemaName);
+                    continue;
+                }
+                catch (error) {
+                    logger(`Error parsing schemaData for ${schemaName}:`, error);
+                }
+            }
+            else {
+                console.log(`[loadAllSchemasFromDb] ${schemaName}: No file and no schemaData - SKIPPING`);
+            }
+        }
+    }
+    // STEP 3: Find schema files not yet in database (for migration/backward compatibility)
+    const completeSchemas = await listCompleteSchemaFiles();
+    for (const schemaFileInfo of completeSchemas) {
+        // Only process if not already in result
+        if (!processedSchemaNames.has(schemaFileInfo.name)) {
+            try {
+                const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
+                const schemaFile = JSON.parse(content);
+                // Import this schema to database (mark as non-draft since it's in a file)
+                const { addSchemaToDb } = await import('./db.js');
+                const schemaRecord = await addSchemaToDb({
+                    name: schemaFile.metadata.name,
+                    version: schemaFile.version,
+                    createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+                    updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+                }, schemaFile.id, JSON.stringify(schemaFile, null, 2), false);
+                result.push({
+                    schema: schemaFile,
+                    isDraft: false,
+                    source: 'file',
+                    schemaRecordId: schemaRecord.id || undefined,
+                });
+                processedSchemaNames.add(schemaFileInfo.name);
+            }
+            catch (error) {
+                logger(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Extract the schema name from a schemaId string
+ * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`
+ * @returns The schema name, or null if the format is invalid
+ */
+function getSchemaNameFromId(schemaId) {
+    if (!schemaId) {
+        return null;
+    }
+    const lastDashIndex = schemaId.lastIndexOf('-');
+    if (lastDashIndex === -1 || lastDashIndex === 0 || lastDashIndex === schemaId.length - 1) {
+        return null;
+    }
+    return schemaId.substring(0, lastDashIndex);
+}
+
+export { createSchema, getLatestSchemaVersion, getSchemaNameFromId, listCompleteSchemaFiles, listLatestSchemaFiles, listSchemaFiles, loadAllSchemasFromDb, readSchema };
+//# sourceMappingURL=schema.js.map

package/dist/helpers/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sources":["../../../src/helpers/schema.ts"],"sourcesContent":["import { BaseFileManager } from './FileManager/BaseFileManager'\nimport { Model } from '@/Model/Model'\nimport { SchemaFileFormat } from '@/types/import'\nimport debug from 'debug'\n\nconst logger = debug('seedSdk:helpers:schema')\n/**\n * \n * Schema type definition\n * A Schema is a collection of Models with a name and version\n */\nexport type Schema = {\n  id?: string\n  name?: string\n  metadata?: {\n    name: string\n    createdAt: string\n    updatedAt: string\n  }\n  version: number\n  models: Model[]\n}\n\n\n/**\n * Sanitize a schema name to be filesystem-safe\n * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores\n * Converts spaces to underscores\n * Removes leading/trailing underscores\n * \n * @param name - Schema name to sanitize\n * @returns Sanitized name safe for use in filenames\n */\nconst sanitizeSchemaName = (name: string): string => {\n  return name\n    .replace(/[^a-zA-Z0-9\\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore\n    .replace(/\\s+/g, '_') // Convert spaces to underscores\n    .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores\n    .replace(/_+/g, '_') // Collapse multiple underscores to single\n}\n\n/**\n * Generate filename for a schema\n * Format: {schemaFileId}_{schemaName}_v{version}.json\n * \n * The ID-first format ensures all files for a schema group together when sorted alphabetically.\n * \n * @param name - Schema name\n * @param version - Schema version\n * @param schemaFileId - Schema file ID (required)\n */\nconst getSchemaFilename = (name: string, version: number, schemaFileId: string): string => {\n  const sanitizedName = sanitizeSchemaName(name)\n  return `${schemaFileId}_${sanitizedName}_v${version}.json`\n}\n\n/**\n * Get the full file path for a schema\n * Format: {schemaFileId}_{schemaName}_v{version}.json\n * \n * The ID-first format ensures all files for a schema group together when sorted alphabetically.\n * \n * @param name - Schema name\n * @param version - Schema version\n * @param schemaFileId - Schema file ID (required)\n */\nconst getSchemaFilePath = (name: string, version: number, schemaFileId: string): string => {\n  const path = BaseFileManager.getPathModule()\n  const filename = getSchemaFilename(name, version, schemaFileId)\n  const workingDir = BaseFileManager.getWorkingDir()\n  return path.join(workingDir, filename)\n}\n\n/**\n * Create a new schema file\n * @param schema - The schema object to save\n * @param schemaFileId - Schema file ID (required)\n * @throws Error if schema already exists or if workingDir is invalid\n */\nexport const createSchema = async (schema: Schema, schemaFileId: string): Promise<void> => {\n  if (!schema.name || !schema.version) {\n    throw new Error('Schema must have a name and version')\n  }\n\n  const filePath = getSchemaFilePath(schema.name, schema.version, schemaFileId)\n\n  // Check if schema already exists\n  const exists = await BaseFileManager.pathExists(filePath)\n  if (exists) {\n    throw new Error(`Schema ${schema.name} v${schema.version} already exists`)\n  }\n\n  // Ensure working directory exists\n  const workingDir = BaseFileManager.getWorkingDir()\n  await BaseFileManager.createDirIfNotExists(workingDir)\n\n  // Write schema to file\n  const content = JSON.stringify(schema, null, 2)\n  await BaseFileManager.saveFile(filePath, content)\n}\n\n/**\n * Read a schema file by name and version\n * @param name - The name of the schema\n * @param version - The version of the schema\n * @param schemaFileId - Schema file ID (required)\n * @returns The schema object, or null if not found\n */\nexport const readSchema = async (\n  name: string,\n  version: number,\n  schemaFileId: string,\n): Promise<Schema | null> => {\n  const filePath = getSchemaFilePath(name, version, schemaFileId)\n\n  const exists = await BaseFileManager.pathExists(filePath)\n  if (!exists) {\n    return null\n  }\n\n  try {\n    const content = await BaseFileManager.readFileAsString(filePath)\n    return JSON.parse(content) as Schema\n  } catch (error) {\n    throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`)\n  }\n}\n\n/**\n * Update an existing schema file\n * @param schema - The updated schema object (must have same name and version as existing)\n * @param schemaFileId - Schema file ID (required)\n * @throws Error if schema doesn't exist\n */\nexport async function updateSchema(schema: Schema, schemaFileId: string): Promise<void> {\n  if (!schema.name || !schema.version) {\n    throw new Error('Schema must have a name and version')\n  }\n\n  const filePath = getSchemaFilePath(schema.name, schema.version, schemaFileId)\n\n  // Check if schema exists\n  const exists = await BaseFileManager.pathExists(filePath)\n  if (!exists) {\n    throw new Error(`Schema ${schema.name} v${schema.version} does not exist`)\n  }\n\n  // Write updated schema to file\n  const content = JSON.stringify(schema, null, 2)\n  await BaseFileManager.saveFile(filePath, content)\n}\n\n/**\n * Delete a schema file\n * @param name - The name of the schema\n * @param version - The version of the schema\n * @param schemaFileId - Schema file ID (required)\n * @throws Error if schema doesn't exist\n */\nexport async function deleteSchema(\n  name: string,\n  version: number,\n  schemaFileId: string,\n): Promise<void> {\n  const filePath = getSchemaFilePath(name, version, schemaFileId)\n\n  // Check if schema exists\n  const exists = await BaseFileManager.pathExists(filePath)\n  if (!exists) {\n    throw new Error(`Schema ${name} v${version} does not exist`)\n  }\n\n  // Delete the file\n  const fs = await BaseFileManager.getFs()\n  const path = BaseFileManager.getPathModule()\n  \n  try {\n    await fs.promises.unlink(filePath)\n  } catch (error) {\n    throw new Error(`Failed to delete schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`)\n  }\n}\n\n/**\n * List all schema files in the working directory\n * Only returns files that are NOT already complete schema files (i.e., files without $schema field)\n * This allows processing of minimal import files while skipping already-processed schema files\n * @returns Array of objects containing name, version, and file path for each schema\n */\nexport async function listSchemaFiles(): Promise<Array<{ name: string; version: number; filePath: string }>> {\n  const fs = await BaseFileManager.getFs()\n  const path = BaseFileManager.getPathModule()\n\n  // Check if working directory exists\n  const workingDir = BaseFileManager.getWorkingDir()\n\n  try {\n    const files = await fs.promises.readdir(workingDir)\n    const schemas: Array<{ name: string; version: number; filePath: string }> = []\n\n    for (const file of files) {\n      // Match filename pattern: {name}-v{version}.json\n      const match = file.match(/^(.+)-v(\\d+)\\.json$/)\n      if (match) {\n        const [, name, versionStr] = match\n        const version = parseInt(versionStr, 10)\n        \n        if (!isNaN(version)) {\n          const filePath = path.join(workingDir, file)\n          \n          // Check if this file is already a complete schema file (has $schema field)\n          // If it is, skip it since it's already been processed\n          try {\n            const content = await BaseFileManager.readFileAsString(filePath)\n            const data = JSON.parse(content) as any\n            \n            // Skip files that already have $schema (complete schema format)\n            // These are already processed and don't need to be imported again\n            if (data.$schema) {\n              continue\n            }\n          } catch (error) {\n            // If we can't read/parse the file, skip it\n            continue\n          }\n          \n          schemas.push({\n            name,\n            version,\n            filePath,\n          })\n        }\n      }\n    }\n\n    return schemas\n  } catch (error) {\n    throw new Error(`Failed to list schemas: ${error instanceof Error ? error.message : String(error)}`)\n  }\n}\n\n/**\n * List all complete schema files in the working directory\n * Only returns files that are complete schema files (i.e., files with $schema field)\n * These are already-processed schema files that need to be loaded into the model store\n * @returns Array of objects containing name, version, and file path for each complete schema\n */\nexport async function listCompleteSchemaFiles(): Promise<Array<{ name: string; version: number; filePath: string; schemaFileId?: string }>> {\n  const fs = await BaseFileManager.getFs()\n  const path = BaseFileManager.getPathModule()\n\n  // Check if working directory exists\n  const workingDir = BaseFileManager.getWorkingDir()\n\n  try {\n    // Check if directory exists before trying to read it\n    const dirExists = await BaseFileManager.pathExists(workingDir)\n    if (!dirExists) {\n      // Directory doesn't exist yet - return empty array (not an error condition)\n      logger(`Working directory does not exist yet: ${workingDir}, returning empty schema list`)\n      return []\n    }\n    \n    const files = await fs.promises.readdir(workingDir)\n    const schemas: Array<{ name: string; version: number; filePath: string; schemaFileId?: string }> = []\n\n    for (const file of files) {\n      // Match filename pattern: {schemaFileId}_{schemaName}_v{version}.json\n      const match = file.match(/^(.+)_(.+)_v(\\d+)\\.json$/)\n      \n      if (match) {\n        const [, schemaFileId, schemaName, versionStr] = match\n        const version = parseInt(versionStr, 10)\n        \n        if (!isNaN(version)) {\n          const filePath = path.join(workingDir, file)\n          \n          // Check if this file is a complete schema file (has $schema field)\n          try {\n            const content = await BaseFileManager.readFileAsString(filePath)\n            const data = JSON.parse(content) as any\n            \n            // Only include files that have $schema (complete schema format)\n            if (data.$schema && data.metadata?.name) {\n              // CRITICAL: Use schemaFileId from filename (source of truth), not from JSON content\n              // The filename pattern is {schemaFileId}_{schemaName}_v{version}.json\n              // The JSON content's id might be out of sync, but the filename tells us what file actually exists\n              schemas.push({\n                name: data.metadata.name,\n                version: data.version || version,\n                filePath,\n                schemaFileId: schemaFileId, // Use from filename, not data.id\n              })\n            }\n          } catch (error) {\n            // If we can't read/parse the file, skip it\n            continue\n          }\n        }\n      }\n    }\n\n    return schemas\n  } catch (error) {\n    throw new Error(`Failed to list complete schemas: ${error instanceof Error ? error.message : String(error)}`)\n  }\n}\n\n/**\n * Find a schema by name (returns the latest version if multiple versions exist)\n * @param name - The name of the schema\n * @returns The schema with the highest version, or null if not found\n */\nexport async function findSchemaByName(\n  name: string,\n): Promise<Schema | null> {\n  const schemas = await listCompleteSchemaFiles()\n  const matchingSchemas = schemas.filter((s) => s.name === name)\n\n  if (matchingSchemas.length === 0) {\n    return null\n  }\n\n  // Find the schema with the highest version\n  const latest = matchingSchemas.reduce((prev, current) =>\n    current.version > prev.version ? current : prev,\n  )\n\n  if (!latest.schemaFileId) {\n    throw new Error(`Schema ${latest.name} v${latest.version} is missing schemaFileId`)\n  }\n\n  return readSchema(latest.name, latest.version, latest.schemaFileId)\n}\n\n/**\n * Get the latest version number for a schema by name\n * Only considers complete schema files (with $schema field)\n * @param name - The name of the schema\n * @returns The latest version number, or 0 if no schema found\n */\nexport async function getLatestSchemaVersion(\n  name: string,\n): Promise<number> {\n  const completeSchemas = await listCompleteSchemaFiles()\n  const matchingSchemas = completeSchemas.filter((s) => s.name === name)\n\n  if (matchingSchemas.length === 0) {\n    return 0\n  }\n\n  // Find the schema with the highest version\n  const latest = matchingSchemas.reduce((prev, current) =>\n    current.version > prev.version ? current : prev,\n  )\n\n  return latest.version\n}\n\n/**\n * Get only the latest version of each schema\n * @returns Array of objects containing name, version, and file path for the latest version of each schema\n */\nexport async function listLatestSchemaFiles(): Promise<Array<{ name: string; version: number; filePath: string }>> {\n  const completeSchemas = await listCompleteSchemaFiles()\n  \n  // Group by schema name and keep only the latest version of each\n  const schemaMap = new Map<string, { name: string; version: number; filePath: string }>()\n  \n  for (const schema of completeSchemas) {\n    const existing = schemaMap.get(schema.name)\n    if (!existing || schema.version > existing.version) {\n      schemaMap.set(schema.name, schema)\n    }\n  }\n  \n  return Array.from(schemaMap.values())\n}\n\n/**\n * Filter an array of schemas to only include the latest version for each schema name\n * Works with any object that has a name (via metadata.name or name property) and a version property\n * @param schemas - Array of schema objects\n * @returns Array containing only the latest version of each schema\n */\nexport function filterLatestSchemas<T extends { name?: string; metadata?: { name: string }; version: number }>(schemas: T[]): T[] {\n  // Group by schema name and keep only the latest version of each\n  const schemaMap = new Map<string, T>()\n  \n  for (const schema of schemas) {\n    const schemaName = schema.metadata?.name || schema.name\n    if (!schemaName) {\n      continue // Skip schemas without a name\n    }\n    \n    const existing = schemaMap.get(schemaName)\n    if (!existing || schema.version > existing.version) {\n      schemaMap.set(schemaName, schema)\n    }\n  }\n  \n  return Array.from(schemaMap.values())\n}\n\n/**\n * Unified schema loading function that queries database first, then merges with files\n * Returns all schemas with their draft status and source information\n * @returns Array of schema objects with metadata about their state\n */\nexport async function loadAllSchemasFromDb(): Promise<Array<{\n  schema: SchemaFileFormat\n  isDraft: boolean\n  source: 'db' | 'file' | 'db+file'\n  schemaRecordId?: number\n}>> {\n  const { BaseDb } = await import('@/db/Db/BaseDb')\n  const { schemas: schemasTable } = await import('@/seedSchema/SchemaSchema')\n  const { desc } = await import('drizzle-orm')\n\n  const db = BaseDb.getAppDb()\n  if (!db) {\n    throw new Error('Database not found')\n  }\n\n  const result: Array<{\n    schema: SchemaFileFormat\n    isDraft: boolean\n    source: 'db' | 'file' | 'db+file'\n    schemaRecordId?: number\n  }> = []\n\n  // STEP 1: Query all schemas from database\n  // Also do a direct SQL query to verify what's actually in the database\n  const { sql } = await import('drizzle-orm')\n  const directQuery = await db.run(sql.raw(`SELECT name, version, schema_file_id, id FROM schemas ORDER BY name, version DESC`))\n  console.log(`[loadAllSchemasFromDb] Direct SQL query result:`, directQuery.rows?.map((row: any) => ({ name: row[0], version: row[1], schemaFileId: row[2], id: row[3] })) || [])\n  \n  const dbSchemas = await db\n    .select()\n    .from(schemasTable)\n    .orderBy(schemasTable.name, desc(schemasTable.version))\n\n  console.log(`[loadAllSchemasFromDb] Drizzle query returned ${dbSchemas.length} schemas:`, dbSchemas.map(s => ({ name: s.name, version: s.version, schemaFileId: s.schemaFileId, isDraft: s.isDraft, id: s.id })))\n  console.log(`[loadAllSchemasFromDb] Schema names in query result:`, dbSchemas.map(s => s.name))\n\n  const processedSchemaNames = new Set<string>()\n\n  // STEP 2: Process each database schema\n  for (const dbSchema of dbSchemas) {\n    const schemaName = dbSchema.name\n\n    console.log(`[loadAllSchemasFromDb] Processing schema: ${schemaName} (id: ${dbSchema.id}, isDraft: ${dbSchema.isDraft}, hasSchemaData: ${!!dbSchema.schemaData}, schemaFileId: ${dbSchema.schemaFileId})`)\n\n    // Skip if we've already processed a newer version of this schema\n    if (processedSchemaNames.has(schemaName)) {\n      console.log(`[loadAllSchemasFromDb] Skipping ${schemaName} - already processed`)\n      continue\n    }\n\n    // If it's a draft, load from schemaData\n    if (dbSchema.isDraft === true && dbSchema.schemaData) {\n      try {\n        let schemaFile = JSON.parse(dbSchema.schemaData) as SchemaFileFormat\n        \n          // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData\n          // This ensures models added to the database are included even if they're not in schemaData\n          // Build merged models without mutating schemaFile (read-only approach)\n          let mergedModels = { ...(schemaFile.models || {}) }\n          if (dbSchema.id) {\n            const { loadModelsFromDbForSchema } = await import('@/helpers/db')\n            const dbModels = await loadModelsFromDbForSchema(dbSchema.id)\n            if (Object.keys(dbModels).length > 0) {\n              // Merge: database models take precedence for properties, but preserve schemaData models for full structure\n              mergedModels = {\n                ...mergedModels,\n                ...dbModels,\n              }\n              // For models that exist in both, merge properties (database properties override)\n              for (const [modelName, dbModel] of Object.entries(dbModels)) {\n                if (mergedModels[modelName]) {\n                  // Merge properties, with database properties taking precedence\n                  mergedModels[modelName] = {\n                    ...mergedModels[modelName],\n                    properties: {\n                      ...mergedModels[modelName].properties,\n                      ...dbModel.properties,\n                    },\n                  }\n                }\n              }\n            }\n          }\n          \n          // Create new schemaFile object with merged models (read-only approach)\n          schemaFile = {\n            ...schemaFile,\n            models: mergedModels,\n          }\n        \n        result.push({\n          schema: schemaFile,\n          isDraft: true,\n          source: 'db',\n          schemaRecordId: dbSchema.id || undefined,\n        })\n        processedSchemaNames.add(schemaName)\n        continue\n      } catch (error) {\n        logger(`Error parsing schemaData for ${schemaName}:`, error)\n        // Fall through to file-based loading\n      }\n    }\n\n    // If it's not a draft and has schemaFileId, try to load from file\n    if (dbSchema.isDraft === false && dbSchema.schemaFileId) {\n      let completeSchemas: Array<{ name: string; version: number; filePath: string; schemaFileId?: string }> = []\n      try {\n        completeSchemas = await listCompleteSchemaFiles()\n      } catch (error) {\n        // If we can't list schema files (e.g., directory doesn't exist yet), continue without file-based loading\n        logger(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`)\n      }\n      const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName)\n      \n      if (matchingSchemas.length > 0) {\n        // Find the schema with the highest version\n        const latest = matchingSchemas.reduce((prev, current) =>\n          current.version > prev.version ? current : prev,\n        )\n\n        try {\n          // Read the file directly to get SchemaFileFormat\n          const content = await BaseFileManager.readFileAsString(latest.filePath)\n          const schemaFile = JSON.parse(content) as SchemaFileFormat\n\n          // Check if file is newer than DB record\n          const fileUpdatedAt = new Date(schemaFile.metadata.updatedAt).getTime()\n          const dbUpdatedAt = dbSchema.updatedAt || 0\n\n          // If file is newer, update DB with file content\n          if (fileUpdatedAt > dbUpdatedAt && schemaFile.id === dbSchema.schemaFileId) {\n            const { addSchemaToDb } = await import('@/helpers/db')\n            await addSchemaToDb(\n              {\n                name: schemaName,\n                version: schemaFile.version,\n                createdAt: new Date(schemaFile.metadata.createdAt).getTime(),\n                updatedAt: fileUpdatedAt,\n              },\n              schemaFile.id,\n              JSON.stringify(schemaFile, null, 2),\n              false, // isDraft = false\n            )\n          }\n\n          result.push({\n            schema: schemaFile,\n            isDraft: false,\n            source: 'db+file',\n            schemaRecordId: dbSchema.id || undefined,\n          })\n          processedSchemaNames.add(schemaName)\n          continue\n        } catch (error) {\n          logger(`Error loading schema file for ${schemaName}:`, error)\n          // Fall through to try loading from schemaData if available\n        }\n      }\n\n      // If file doesn't exist but we have schemaData, use that\n      console.log(`[loadAllSchemasFromDb] ${schemaName}: file not found, checking schemaData...`)\n      if (dbSchema.schemaData) {\n        try {\n          let schemaFile = JSON.parse(dbSchema.schemaData) as SchemaFileFormat\n          \n          // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData\n          // This ensures models added to the database are included even if they're not in schemaData\n          // Build merged models without mutating schemaFile (read-only approach)\n          let mergedModels = { ...(schemaFile.models || {}) }\n          if (dbSchema.id) {\n            const { loadModelsFromDbForSchema } = await import('@/helpers/db')\n            const dbModels = await loadModelsFromDbForSchema(dbSchema.id)\n            if (Object.keys(dbModels).length > 0) {\n              // Merge: database models take precedence for properties, but preserve schemaData models for full structure\n              mergedModels = {\n                ...mergedModels,\n                ...dbModels,\n              }\n              // For models that exist in both, merge properties (database properties override)\n              for (const [modelName, dbModel] of Object.entries(dbModels)) {\n                if (mergedModels[modelName]) {\n                  // Merge properties, with database properties taking precedence\n                  mergedModels[modelName] = {\n                    ...mergedModels[modelName],\n                    properties: {\n                      ...mergedModels[modelName].properties,\n                      ...dbModel.properties,\n                    },\n                  }\n                }\n              }\n            }\n          }\n          \n          // Create new schemaFile object with merged models (read-only approach)\n          schemaFile = {\n            ...schemaFile,\n            models: mergedModels,\n          }\n          \n        console.log(`[loadAllSchemasFromDb] Adding schema from schemaData: ${schemaName} (id: ${dbSchema.id}, schemaFileId: ${dbSchema.schemaFileId})`)\n        result.push({\n          schema: schemaFile,\n          isDraft: false,\n          source: 'db',\n          schemaRecordId: dbSchema.id || undefined,\n        })\n        processedSchemaNames.add(schemaName)\n        continue\n        } catch (error) {\n          logger(`Error parsing schemaData for ${schemaName}:`, error)\n        }\n      } else {\n        console.log(`[loadAllSchemasFromDb] ${schemaName}: No file and no schemaData - SKIPPING`)\n      }\n    }\n  }\n\n  // STEP 3: Find schema files not yet in database (for migration/backward compatibility)\n  const completeSchemas = await listCompleteSchemaFiles()\n\n  for (const schemaFileInfo of completeSchemas) {\n    // Only process if not already in result\n    if (!processedSchemaNames.has(schemaFileInfo.name)) {\n      try {\n        const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath)\n        const schemaFile = JSON.parse(content) as SchemaFileFormat\n\n        // Import this schema to database (mark as non-draft since it's in a file)\n        const { addSchemaToDb } = await import('@/helpers/db')\n        const schemaRecord = await addSchemaToDb(\n          {\n            name: schemaFile.metadata.name,\n            version: schemaFile.version,\n            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),\n            updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),\n          },\n          schemaFile.id,\n          JSON.stringify(schemaFile, null, 2),\n          false, // isDraft = false (it's in a file, so it's published)\n        )\n\n        result.push({\n          schema: schemaFile,\n          isDraft: false,\n          source: 'file',\n          schemaRecordId: schemaRecord.id || undefined,\n        })\n        processedSchemaNames.add(schemaFileInfo.name)\n      } catch (error) {\n        logger(`Error loading schema file ${schemaFileInfo.filePath}:`, error)\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Migration helper: Migrate existing file-based schemas to the database\n * This function should be called once to migrate existing schema files to the new database-first approach\n * All existing schemas will be marked as published (isDraft = false) since they already exist in files\n * @returns Number of schemas migrated\n */\nexport async function migrateFileSchemasToDb(): Promise<number> {\n  const { BaseDb } = await import('@/db/Db/BaseDb')\n  const { schemas: schemasTable } = await import('@/seedSchema/SchemaSchema')\n  const { eq } = await import('drizzle-orm')\n  const { addSchemaToDb } = await import('@/helpers/db')\n\n  const db = BaseDb.getAppDb()\n  if (!db) {\n    throw new Error('Database not found')\n  }\n\n  logger('Starting migration of file-based schemas to database')\n\n  // Get all complete schema files\n  const completeSchemas = await listCompleteSchemaFiles()\n  let migratedCount = 0\n\n  for (const schemaFileInfo of completeSchemas) {\n    try {\n      // Read the schema file\n      const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath)\n      const schemaFile = JSON.parse(content) as SchemaFileFormat\n\n      if (!schemaFile.$schema || !schemaFile.metadata?.name) {\n        logger(`Skipping invalid schema file: ${schemaFileInfo.filePath}`)\n        continue\n      }\n\n      const schemaName = schemaFile.metadata.name\n\n      // Check if schema already exists in database\n      const existingSchemas = await db\n        .select()\n        .from(schemasTable)\n        .where(eq(schemasTable.name, schemaName))\n        .limit(1)\n\n      // Only migrate if it doesn't exist or if existing record doesn't have schemaFileId\n      if (existingSchemas.length === 0 || !existingSchemas[0].schemaFileId) {\n        // Add schema to database as published (isDraft = false)\n        await addSchemaToDb(\n          {\n            name: schemaName,\n            version: schemaFile.version,\n            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),\n            updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),\n          },\n          schemaFile.id, // schemaFileId\n          JSON.stringify(schemaFile, null, 2), // schemaData\n          false, // isDraft = false (it's in a file, so it's published)\n        )\n\n        migratedCount++\n        logger(`Migrated schema: ${schemaName} v${schemaFile.version}`)\n      } else {\n        logger(`Schema ${schemaName} already exists in database, skipping`)\n      }\n    } catch (error) {\n      logger(`Error migrating schema file ${schemaFileInfo.filePath}:`, error)\n    }\n  }\n\n  logger(`Migration complete: ${migratedCount} schemas migrated`)\n  return migratedCount\n}\n\n/**\n * Extract the schema name from a schemaId string\n * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`\n * @returns The schema name, or null if the format is invalid\n */\nexport function getSchemaNameFromId(schemaId: string | null | undefined): string | null {\n  if (!schemaId) {\n    return null\n  }\n  const lastDashIndex = schemaId.lastIndexOf('-')\n  if (lastDashIndex === -1 || lastDashIndex === 0 || lastDashIndex === schemaId.length - 1) {\n    return null\n  }\n  return schemaId.substring(0, lastDashIndex)\n}\n\n"],"names":[],"mappings":"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"}

package/dist/helpers/updateMachineContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateMachineContext.js","sources":["../../../src/helpers/updateMachineContext.ts"],"sourcesContent":["import { ActionFunction, assign } from 'xstate'\n\ntype UpdateMachineContext = {\n  actions: ActionFunction<any, any, any, any, any, any, any, any, any>[] | any\n}\nexport const updateMachineContext: UpdateMachineContext = {\n  actions: assign(({ context, event }) => {\n    const newContext = Object.assign({}, context)\n\n    for (let i = 0; i < Object.keys(event).length; i++) {\n      const key = Object.keys(event)[i]\n      if (key === 'type') {\n        continue\n      }\n      newContext[key] = event[key]\n    }\n    return {\n      ...newContext,\n    }\n  }),\n}\n"],"names":[],"mappings":";;AAKO,MAAM,oBAAoB,GAAyB;IACxD,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAI;QACrC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC;AAE7C,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACjC,YAAA,IAAI,GAAG,KAAK,MAAM,EAAE;gBAClB;YACF;YACA,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;QAC9B;QACA,OAAO;AACL,YAAA,GAAG,UAAU;SACd;AACH,IAAA,CAAC,CAAC;;;;;"}