@seedprotocol/sdk 0.4.1 → 0.4.3

package/dist/helpers/updateSchema.js

@@ -1,721 +0,0 @@
-import { BaseFileManager } from './FileManager/BaseFileManager.js';
-import { getLatestSchemaVersion } from './schema.js';
-import 'pluralize';
-import { BaseDb } from '../db/Db/BaseDb.js';
-import '../seedSchema/SeedSchema.js';
-import '../seedSchema/VersionSchema.js';
-import '../seedSchema/MetadataSchema.js';
-import '../seedSchema/AppStateSchema.js';
-import { models } from '../seedSchema/ModelSchema.js';
-import '../seedSchema/ModelUidSchema.js';
-import '../seedSchema/PropertyUidSchema.js';
-import '../seedSchema/ConfigSchema.js';
-import '../seedSchema/SchemaSchema.js';
-import '../seedSchema/ModelSchemaSchema.js';
-import { eq } from 'drizzle-orm';
-import { ModelPropertyDataTypes } from './property/index.js';
-import debug from 'debug';
-
-const logger = debug('seedSdk:helpers:updateSchema');
-/**
- * Get the file path for a schema file
- */
-/**
- * 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
-};
-/**
- * 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 workingDir = BaseFileManager.getWorkingDir();
-    const sanitizedName = sanitizeSchemaName(name);
-    const filename = `${schemaFileId}_${sanitizedName}_v${version}.json`;
-    return path.join(workingDir, filename);
-};
-/**
- * Get schemaFileId from database for a schema
- * @param schemaName - Schema name
- * @returns Schema file ID
- * @throws Error if schema not found or missing schemaFileId
- */
-async function getSchemaFileId(schemaName) {
-    const { BaseDb } = await import('../db/Db/BaseDb.js');
-    const db = BaseDb.getDb();
-    const { schemas } = await import('../seedSchema/SchemaSchema.js');
-    const { eq, desc } = await import('drizzle-orm');
-    const dbSchema = await db
-        .select()
-        .from(schemas)
-        .where(eq(schemas.name, schemaName))
-        .orderBy(desc(schemas.version))
-        .limit(1);
-    if (dbSchema.length === 0 || !dbSchema[0].schemaFileId) {
-        throw new Error(`Schema ${schemaName} not found in database or missing schemaFileId`);
-    }
-    return dbSchema[0].schemaFileId;
-}
-/**
- * Get model name from modelId
- * @param modelId - The model ID to look up
- * @returns The model name, or undefined if not found
- */
-async function getModelNameFromId(modelId) {
-    if (!modelId) {
-        return undefined;
-    }
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    const modelRecords = await db
-        .select()
-        .from(models)
-        .where(eq(models.id, modelId))
-        .limit(1);
-    if (modelRecords.length === 0) {
-        return undefined;
-    }
-    return modelRecords[0].name;
-}
-/**
- * Convert a TProperty/ModelPropertyMachineContext to SchemaPropertyUpdate format
- * This function converts the internal property representation to the schema file format
- * @param property - The TProperty instance to convert
- * @param modelName - The name of the model this property belongs to
- * @param propertyName - The name of the property
- * @returns A SchemaPropertyUpdate object ready to be passed to updateModelProperties
- */
-async function convertPropertyToSchemaUpdate(property, modelName, propertyName) {
-    const updates = {};
-    // Convert dataType to type
-    if (property.dataType) {
-        updates.type = property.dataType;
-    }
-    // Handle Relation type
-    if (property.dataType === ModelPropertyDataTypes.Relation) {
-        if (property.ref) {
-            updates.model = property.ref;
-        }
-        else if (property.refModelId) {
-            // If ref is not set but refModelId is, get the model name from the database
-            const refModelName = await getModelNameFromId(property.refModelId);
-            if (refModelName) {
-                updates.model = refModelName;
-            }
-        }
-    }
-    // Handle List type
-    if (property.dataType === ModelPropertyDataTypes.List) {
-        if (property.refValueType) {
-            updates.items = {
-                type: property.refValueType,
-            };
-            if (property.ref) {
-                updates.items.model = property.ref;
-            }
-            else if (property.refModelId) {
-                // If ref is not set but refModelId is, get the model name from the database
-                const refModelName = await getModelNameFromId(property.refModelId);
-                if (refModelName) {
-                    updates.items.model = refModelName;
-                }
-            }
-        }
-    }
-    // Handle storage configuration (for Text properties with storage)
-    if (property.storageType || property.localStorageDir || property.filenameSuffix) {
-        const storageType = property.storageType || 'ItemStorage'; // Default to ItemStorage if not specified
-        updates.storage = {
-            type: storageType,
-        };
-        if (property.localStorageDir) {
-            updates.storage.path = property.localStorageDir;
-        }
-        if (property.filenameSuffix) {
-            updates.storage.extension = property.filenameSuffix;
-        }
-    }
-    return {
-        modelName,
-        propertyName,
-        updates,
-    };
-}
-/**
- * Update model properties in a schema and create a new version
- * @param schemaName - The name of the schema to update
- * @param propertyUpdates - Array of property updates to apply
- * @param modelUpdates - Optional array of model renames
- * @returns The file path of the new schema version
- * @throws Error if schema not found or updates are invalid
- */
-async function updateModelProperties(schemaName, propertyUpdates, modelUpdates) {
-    // Get the latest version of the schema
-    const latestVersion = await getLatestSchemaVersion(schemaName);
-    if (latestVersion === 0) {
-        throw new Error(`Schema ${schemaName} not found`);
-    }
-    // Get schemaFileId from database
-    const schemaFileId = await getSchemaFileId(schemaName);
-    // Load the latest schema file
-    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    // Create a copy of the schema for the new version
-    // Preserve schema ID and all model/property IDs
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        // Preserve schema ID from previous version
-        id: schemaFile.id,
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        // Deep copy models to preserve IDs
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
-            modelName,
-            {
-                ...model,
-                // Preserve model ID
-                id: model.id,
-                // Deep copy properties to preserve IDs
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    {
-                        ...prop,
-                        // Preserve property ID
-                        id: prop.id,
-                    },
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Updated model properties: ${propertyUpdates.map(u => `${u.modelName}.${u.propertyName}`).join(', ')}`,
-                changes: propertyUpdates.map(update => ({
-                    type: 'property_update',
-                    modelName: update.modelName,
-                    propertyName: update.propertyName,
-                    updates: update.updates,
-                })),
-            },
-        ],
-    };
-    // Apply model renames first (if any)
-    if (modelUpdates && modelUpdates.length > 0) {
-        for (const modelUpdate of modelUpdates) {
-            if (updatedSchema.models[modelUpdate.oldName]) {
-                // Rename the model in the models object
-                updatedSchema.models[modelUpdate.newName] = updatedSchema.models[modelUpdate.oldName];
-                delete updatedSchema.models[modelUpdate.oldName];
-                // Update any property references to this model
-                for (const modelName in updatedSchema.models) {
-                    const model = updatedSchema.models[modelName];
-                    for (const propertyName in model.properties) {
-                        const property = model.properties[propertyName];
-                        if (property.model === modelUpdate.oldName) {
-                            property.model = modelUpdate.newName;
-                        }
-                        if (property.items?.model === modelUpdate.oldName) {
-                            property.items.model = modelUpdate.newName;
-                        }
-                    }
-                }
-                // Add to migration changes
-                updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                    type: 'model_rename',
-                    oldName: modelUpdate.oldName,
-                    newName: modelUpdate.newName,
-                });
-            }
-        }
-    }
-    // Apply property updates
-    for (const update of propertyUpdates) {
-        const model = updatedSchema.models[update.modelName];
-        if (!model) {
-            throw new Error(`Model ${update.modelName} not found in schema ${schemaName}`);
-        }
-        if (!model.properties[update.propertyName]) {
-            throw new Error(`Property ${update.propertyName} not found in model ${update.modelName} of schema ${schemaName}`);
-        }
-        // Update the property with new values
-        const property = model.properties[update.propertyName];
-        Object.assign(property, update.updates);
-    }
-    // Write the new schema version to file using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    await BaseFileManager.saveFile(newFilePath, newContent);
-    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
-    await BaseFileManager.waitForFileWithContent(newFilePath);
-    logger(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
-    // Load the new schema file to process models and add them to the database
-    // Extract model renames from migrations to pass to database update
-    const modelRenames = new Map();
-    const latestMigration = updatedSchema.migrations[updatedSchema.migrations.length - 1];
-    for (const change of latestMigration.changes) {
-        if (change.type === 'model_rename') {
-            modelRenames.set(change.oldName, change.newName);
-        }
-    }
-    // Load schema with model renames handled
-    await loadSchemaWithRenames(newFilePath, modelRenames);
-    return newFilePath;
-}
-/**
- * Load a schema file and handle model renames in the database
- * This is a helper function that processes model renames before loading
- */
-async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
-    const content = await BaseFileManager.readFileAsString(schemaFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`File ${schemaFilePath} is not a complete schema file (missing $schema field).`);
-    }
-    const schemaName = schemaFile.metadata?.name;
-    const version = schemaFile.version;
-    if (!schemaName) {
-        throw new Error('Schema name is required in metadata.name');
-    }
-    // Convert to JsonImportSchema format for processing
-    // Remove id fields for JsonImportSchema format (they're not part of the import format)
-    const importData = {
-        name: schemaName,
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
-            modelName,
-            {
-                ...model,
-                // Remove id field for import format
-                id: undefined,
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    {
-                        ...prop,
-                        // Remove id field for import format
-                        id: undefined,
-                    },
-                ])),
-            },
-        ])),
-    };
-    // Use dynamic import to break circular dependency
-    const { createModelsFromJson } = await import('../imports/json.js');
-    // Generate schema ID if missing
-    if (!schemaFile.id) {
-        const { generateId } = await import('./index.js');
-        schemaFile.id = generateId();
-        logger('Generated schema ID for schema:', schemaFile.id);
-    }
-    // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
-    // This ensures Model instances are created with correct IDs
-    const modelFileIds = new Map();
-    const propertyFileIds = new Map();
-    const { generateId } = await import('./index.js');
-    for (const [modelName, model] of Object.entries(schemaFile.models)) {
-        // Generate model ID if missing
-        if (!model.id) {
-            model.id = generateId();
-            logger(`Generated model ID for ${modelName}:`, model.id);
-        }
-        modelFileIds.set(modelName, model.id);
-        const propIds = new Map();
-        for (const [propName, prop] of Object.entries(model.properties)) {
-            // Generate property ID if missing
-            if (!prop.id) {
-                prop.id = generateId();
-                logger(`Generated property ID for ${modelName}.${propName}:`, prop.id);
-            }
-            propIds.set(propName, prop.id);
-        }
-        if (propIds.size > 0) {
-            propertyFileIds.set(modelName, propIds);
-        }
-    }
-    // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
-    const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
-    // Convert schema file metadata to schema input for database
-    const schemaInput = {
-        name: schemaName,
-        version,
-        schemaFileId: schemaFile.id || null,
-        createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
-        updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
-    };
-    // Use dynamic import to break circular dependency
-    const { addSchemaToDb, addModelsToDb } = await import('./db.js');
-    // Add schema to database with schemaFileId
-    const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id);
-    // Add models to database with model renames handled and schemaFileIds
-    await addModelsToDb(modelDefinitions, schemaRecord, modelRenames, {
-        schemaFileId: schemaFile.id,
-        modelFileIds,
-        propertyFileIds,
-    });
-    // Models are now Model instances, no registration needed
-    // They should be created via Model.create() and are accessible via Model static methods
-    for (const [modelName] of Object.entries(modelDefinitions)) {
-        logger('loadSchemaWithRenames - model available:', modelName);
-    }
-    return schemaFilePath;
-}
-/**
- * Rename a property in a model
- * This is a convenience function that updates the property name
- * Note: This creates a new property and you may want to handle the old property separately
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param oldPropertyName - The current property name
- * @param newPropertyName - The new property name
- * @returns The file path of the new schema version
- */
-async function renameModelProperty(schemaName, modelName, oldPropertyName, newPropertyName) {
-    // Get the latest version
-    const latestVersion = await getLatestSchemaVersion(schemaName);
-    if (latestVersion === 0) {
-        throw new Error(`Schema ${schemaName} not found`);
-    }
-    // Get schemaFileId from database
-    const schemaFileId = await getSchemaFileId(schemaName);
-    // Load the latest schema file
-    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    const model = schemaFile.models[modelName];
-    if (!model) {
-        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
-    }
-    if (!model.properties[oldPropertyName]) {
-        throw new Error(`Property ${oldPropertyName} not found in model ${modelName} of schema ${schemaName}`);
-    }
-    if (model.properties[newPropertyName]) {
-        throw new Error(`Property ${newPropertyName} already exists in model ${modelName} of schema ${schemaName}`);
-    }
-    // Create new version with renamed property
-    // Preserve all IDs - when renaming, we keep the same property ID
-    const newVersion = latestVersion + 1;
-    const oldProperty = model.properties[oldPropertyName];
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        models: {
-            ...schemaFile.models,
-            [modelName]: {
-                ...model,
-                id: model.id, // Preserve model ID
-                properties: {
-                    ...Object.fromEntries(Object.entries(model.properties)
-                        .filter(([name]) => name !== oldPropertyName)
-                        .map(([name, prop]) => [name, { ...prop, id: prop.id }])),
-                    [newPropertyName]: {
-                        ...oldProperty,
-                        id: oldProperty.id, // Preserve property ID when renaming
-                    },
-                },
-            },
-        },
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Renamed property ${modelName}.${oldPropertyName} to ${newPropertyName}`,
-                changes: [
-                    {
-                        type: 'property_rename',
-                        modelName,
-                        oldPropertyName,
-                        newPropertyName,
-                    },
-                ],
-            },
-        ],
-    };
-    // Remove the old property name
-    delete updatedSchema.models[modelName].properties[oldPropertyName];
-    // Write the new schema version using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    // Ensure the directory exists before saving
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(newFilePath);
-    await BaseFileManager.createDirIfNotExists(dir);
-    await BaseFileManager.saveFile(newFilePath, newContent);
-    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
-    await BaseFileManager.waitForFileWithContent(newFilePath);
-    logger(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
-    // Use dynamic import to break circular dependency
-    const { loadSchemaFromFile } = await import('../imports/json.js');
-    // Load the new schema file
-    await loadSchemaFromFile(newFilePath);
-    return newFilePath;
-}
-/**
- * Delete a model from a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema or model not found
- */
-async function deleteModelFromSchema(schemaName, modelName, options = {}) {
-    const { removeReferencingProperties = false } = options;
-    // Get the latest version
-    const latestVersion = await getLatestSchemaVersion(schemaName);
-    if (latestVersion === 0) {
-        throw new Error(`Schema ${schemaName} not found`);
-    }
-    // Get schemaFileId from database
-    const schemaFileId = await getSchemaFileId(schemaName);
-    // Load the latest schema file
-    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    if (!schemaFile.models[modelName]) {
-        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
-    }
-    // Create new version without the model
-    // Preserve IDs for remaining models and properties
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        // Preserve IDs for remaining models and their properties
-        models: Object.fromEntries(Object.entries(schemaFile.models)
-            .filter(([name]) => name !== modelName)
-            .map(([name, model]) => [
-            name,
-            {
-                ...model,
-                id: model.id, // Preserve model ID
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    { ...prop, id: prop.id }, // Preserve property ID
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Deleted model ${modelName} from schema`,
-                changes: [
-                    {
-                        type: 'model_delete',
-                        modelName,
-                        removeReferencingProperties,
-                    },
-                ],
-            },
-        ],
-    };
-    // Remove the model
-    delete updatedSchema.models[modelName];
-    // Handle properties that reference this model
-    const propertiesToRemove = [];
-    for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
-        for (const [propertyName, property] of Object.entries(model.properties)) {
-            // Check if property references the deleted model
-            if (property.model === modelName || property.items?.model === modelName) {
-                if (removeReferencingProperties) {
-                    // Mark for removal
-                    propertiesToRemove.push({ modelName: otherModelName, propertyName });
-                }
-                else {
-                    // Remove the reference (set to null or remove model field)
-                    if (property.model === modelName) {
-                        delete property.model;
-                    }
-                    if (property.items?.model === modelName) {
-                        delete property.items.model;
-                        // If items only had model, we might want to remove items entirely
-                        // But for now, just remove the model reference
-                    }
-                }
-            }
-        }
-    }
-    // Remove properties if requested
-    if (removeReferencingProperties) {
-        for (const { modelName: mName, propertyName } of propertiesToRemove) {
-            delete updatedSchema.models[mName].properties[propertyName];
-            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                type: 'property_delete',
-                modelName: mName,
-                propertyName,
-                reason: `Referenced deleted model ${modelName}`,
-            });
-        }
-    }
-    else {
-        // Update migration to note which properties were updated
-        const updatedProperties = [];
-        for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
-            for (const [propertyName, property] of Object.entries(model.properties)) {
-                if (property.model === modelName || property.items?.model === modelName) {
-                    updatedProperties.push({ modelName: otherModelName, propertyName });
-                }
-            }
-        }
-        if (updatedProperties.length > 0) {
-            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                type: 'properties_updated',
-                properties: updatedProperties,
-                reason: `Removed references to deleted model ${modelName}`,
-            });
-        }
-    }
-    // Write the new schema version using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    // Ensure the directory exists before saving
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(newFilePath);
-    await BaseFileManager.createDirIfNotExists(dir);
-    await BaseFileManager.saveFile(newFilePath, newContent);
-    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
-    await BaseFileManager.waitForFileWithContent(newFilePath);
-    logger(`Deleted model ${modelName} from schema ${schemaName} v${newVersion}`);
-    // Use dynamic import to break circular dependency
-    const { loadSchemaFromFile } = await import('../imports/json.js');
-    // Load the new schema file
-    await loadSchemaFromFile(newFilePath);
-    return newFilePath;
-}
-/**
- * Delete a property from a model in a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param propertyName - The name of the property to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema, model, or property not found
- */
-async function deletePropertyFromModel(schemaName, modelName, propertyName, options = {}) {
-    // Get the latest version
-    const latestVersion = await getLatestSchemaVersion(schemaName);
-    if (latestVersion === 0) {
-        throw new Error(`Schema ${schemaName} not found`);
-    }
-    // Get schemaFileId from database
-    const schemaFileId = await getSchemaFileId(schemaName);
-    // Load the latest schema file
-    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    const model = schemaFile.models[modelName];
-    if (!model) {
-        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
-    }
-    if (!model.properties[propertyName]) {
-        throw new Error(`Property ${propertyName} not found in model ${modelName} of schema ${schemaName}`);
-    }
-    // Create new version without the property
-    // Preserve IDs for schema, models, and remaining properties
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([mName, m]) => [
-            mName,
-            {
-                ...m,
-                id: m.id, // Preserve model ID
-                properties: Object.fromEntries(Object.entries(m.properties)
-                    .filter(([propName]) => !(mName === modelName && propName === propertyName))
-                    .map(([propName, prop]) => [
-                    propName,
-                    { ...prop, id: prop.id }, // Preserve property ID
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Deleted property ${modelName}.${propertyName} from schema`,
-                changes: [
-                    {
-                        type: 'property_delete',
-                        modelName,
-                        propertyName,
-                    },
-                ],
-            },
-        ],
-    };
-    // Write the new schema version using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    // Ensure the directory exists before saving
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(newFilePath);
-    await BaseFileManager.createDirIfNotExists(dir);
-    await BaseFileManager.saveFile(newFilePath, newContent);
-    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
-    await BaseFileManager.waitForFileWithContent(newFilePath);
-    logger(`Deleted property ${propertyName} from model ${modelName} in schema ${schemaName} v${newVersion}`);
-    // Use dynamic import to break circular dependency
-    const { loadSchemaFromFile } = await import('../imports/json.js');
-    // Load the new schema file
-    await loadSchemaFromFile(newFilePath);
-    return newFilePath;
-}
-
-export { convertPropertyToSchemaUpdate, deleteModelFromSchema, deletePropertyFromModel, getModelNameFromId, renameModelProperty, updateModelProperties };
-//# sourceMappingURL=updateSchema.js.map