@seedprotocol/sdk 0.4.4 → 0.4.6

package/dist/cjs/{ModelProperty-BRKRREYP.js → ModelProperty-B4pV91tc.js}

@@ -1,390 +1,38 @@
 'use strict';
 
 var xstate = require('xstate');
-var main_cjs = require('./index-C3j3m34a.js');
-require('pluralize');
-var drizzleOrm = require('drizzle-orm');
+var Schema = require('./Schema-TErl3J36.js');
+var main_cjs = require('./index-CXI4VF1H.js');
 var debug = require('debug');
-
-const logger$4 = 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 = main_cjs.BaseFileManager.getPathModule();
-    const workingDir = main_cjs.BaseFileManager.getWorkingDir();
-    const sanitizedName = sanitizeSchemaName(name);
-    const filename = schemaFileId
-        ? `${schemaFileId}_${sanitizedName}_v${version}.json`
-        : `${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 Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.BaseDb$1; });
-    const db = BaseDb.getAppDb();
-    const { schemas } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.SchemaSchema; });
-    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;
-}
-/**
- * Write the full schema to a new version file (e.g. when new models were added).
- * Used when _editedProperties contains 'schema:models' and there are no property-level updates.
- * @param schemaName - Schema name
- * @param schema - Full schema object (e.g. from _buildModelsFromInstances)
- * @returns The file path of the new schema version
- */
-async function writeFullSchemaNewVersion(schemaName, schema) {
-    const latestVersion = await main_cjs.getLatestSchemaVersion(schemaName);
-    const newVersion = latestVersion + 1;
-    const schemaWithNewVersion = {
-        ...schema,
-        version: newVersion,
-        metadata: {
-            ...schema.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        migrations: [
-            ...(schema.migrations || []),
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: 'New schema version (e.g. new models added)',
-                changes: [{ type: 'full_schema_write' }],
-            },
-        ],
-    };
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, schema.id ?? (await getSchemaFileId(schemaName)));
-    const newContent = JSON.stringify(schemaWithNewVersion, null, 2);
-    await main_cjs.BaseFileManager.saveFile(newFilePath, newContent);
-    await main_cjs.BaseFileManager.waitForFileWithContent(newFilePath);
-    logger$4(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
-    return newFilePath;
-}
-/**
- * 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 = main_cjs.BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    const modelRecords = await db
-        .select()
-        .from(main_cjs.models)
-        .where(drizzleOrm.eq(main_cjs.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 === main_cjs.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 === main_cjs.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 main_cjs.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 main_cjs.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 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 ?? undefined);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    await main_cjs.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 main_cjs.BaseFileManager.waitForFileWithContent(newFilePath);
-    logger$4(`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 main_cjs.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,
-            {
-                description: model.description,
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    {
-                        type: prop.type || 'string', // Ensure type is present
-                        ...prop,
-                        // Remove id field for import format (not part of JsonImportSchema)
-                    },
-                ])),
-                indexes: model.indexes,
-            },
-        ])),
-    };
-    // Generate schema ID if missing
-    if (!schemaFile.id) {
-        const { generateId } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.index; });
-        schemaFile.id = generateId();
-        logger$4('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 Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.index; });
-    for (const [modelName, model] of Object.entries(schemaFile.models)) {
-        // Generate model ID if missing
-        if (!model.id) {
-            model.id = generateId();
-            logger$4(`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$4(`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 main_cjs.createModelsFromJson(importData, modelFileIds, propertyFileIds);
-    // Convert schema file metadata to schema input for database
-    const schemaInput = {
-        name: schemaName,
-        version,
-        schemaFileId: schemaFile.id || null,
-        schemaData: null,
-        isDraft: false,
-        isEdited: false,
-        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 Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
-    // 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$4('loadSchemaWithRenames - model available:', modelName);
-    }
-    return schemaFilePath;
-}
+var drizzleOrm = require('drizzle-orm');
+require('./SchemaValidationService-p5BbJV9T.js');
+require('@sinclair/typebox/value');
+require('reflect-metadata');
+require('pluralize');
+require('@sinclair/typebox');
+require('immer');
+require('drizzle-orm/sqlite-core');
+require('nanoid');
+require('nanoid-dictionary');
+require('ethers');
+require('rxjs');
+require('lodash-es');
+require('drizzle-orm/casing');
+require('eventemitter3');
+require('arweave');
+require('fs/promises');
+require('fs');
+require('path');
+require('@libsql/client');
+require('drizzle-orm/libsql');
+require('drizzle-kit/api');
+require('js-yaml');
+require('ts-import');
+require('glob');
+require('rimraf');
+require('child_process');
+require('url');
+require('graphql-request');
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
 /**
@@ -394,11 +42,13 @@ const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
  */
 async function getSchemaNameFromModel(modelName) {
     // Get the latest schema files and find which one contains this model
-    const { listLatestSchemaFiles } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.schema$1; });
+    const schemaHelpersMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.schema$1; });
+    const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const { BaseFileManager } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.BaseFileManager$1; });
+            const fileManagerMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.BaseFileManager$1; });
+            const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
             const schemaFile = JSON.parse(content);
             if (schemaFile.models && schemaFile.models[modelName]) {
@@ -415,7 +65,8 @@ async function getSchemaNameFromModel(modelName) {
 const saveToSchema = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DUtQUerg.js'); });
+        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+        const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
         const validationResult = validationService.validatePropertyStructure(context);
@@ -438,15 +89,16 @@ const saveToSchema = xstate.fromCallback(({ sendBack, input: { context } }) => {
             throw new Error(`Schema not found for model: ${context.modelName}`);
         }
         // Convert property context to SchemaPropertyUpdate
-        const propertyUpdate = await convertPropertyToSchemaUpdate(context, context.modelName, context.name);
+        const propertyUpdate = await Schema.convertPropertyToSchemaUpdate(context, context.modelName, context.name);
         // Update the schema with the property changes
-        await updateModelProperties(schemaName, [propertyUpdate]);
+        await Schema.updateModelProperties(schemaName, [propertyUpdate]);
         // Clear isEdited flag in database after saving to schema file
         try {
-            const { BaseDb } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.BaseDb$1; });
-            const { properties: propertiesTable, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.schema; });
-            const { eq, and } = await import('drizzle-orm');
-            const db = BaseDb.getAppDb();
+            const seedSchemaMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.schema; });
+            const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
+            const drizzleMod = await import('drizzle-orm');
+            const { eq, and } = drizzleMod;
+            const db = main_cjs.BaseDb.getAppDb();
             if (db && context.modelName && context.name) {
                 // Find model by name
                 const modelRecords = await db
@@ -488,12 +140,6 @@ const saveToSchema = xstate.fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-var saveToSchema$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getSchemaNameFromModel: getSchemaNameFromModel,
-    saveToSchema: saveToSchema
-});
-
 const logger$2 = debug('seedSdk:modelProperty:actors:compareAndMarkDraft');
 const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _compareAndMarkDraft = async () => {
@@ -506,7 +152,8 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
         const schemaFileIdForResolve = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
         if (schemaFileIdForResolve && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
             try {
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
+                const dbMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.db; });
+                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 let fromDb;
                 for (let attempt = 0; attempt < 6; attempt++) {
                     fromDb = await getPropertyModelNameAndDataType(schemaFileIdForResolve);
@@ -550,7 +197,8 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
             if (fullContext.modelName && fullContext.name && schemaFileId) {
                 logger$2(`[compareAndMarkDraft] _originalValues not set, but saving to database anyway for property ${context.modelName}:${context.name} (schemaFileId: ${schemaFileId})`);
                 try {
-                    const { savePropertyToDb } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
+                    const dbMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.db; });
+                    const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
                     const contextWithFileId = {
                         ...fullContext,
@@ -609,7 +257,8 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has changes, marking as edited`);
             logger$2(`[compareAndMarkDraft] Context when saving: id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}, name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
             // Use dynamic import to break circular dependency
-            const { savePropertyToDb } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
+            const dbMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.db; });
+            const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
             try {
                 await savePropertyToDb(fullContext);
@@ -622,7 +271,8 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
             // Mark schema as draft if schema name is available
             if (fullContext._schemaName) {
                 // Get the Schema instance and mark it as draft
-                const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CV9hMg8m.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+                const { Schema } = schemaMod;
                 const schema = Schema.create(fullContext._schemaName, {
                     waitForReady: false,
                 });
@@ -638,10 +288,11 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
             // Clear isEdited flag in database
             try {
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { properties: propertiesTable, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.schema; });
-                const { eq, and } = await import('drizzle-orm');
-                const db = BaseDb.getAppDb();
+                const seedSchemaMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.schema; });
+                const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq, and } = drizzleMod;
+                const db = main_cjs.BaseDb.getAppDb();
                 if (db && fullContext.modelName && fullContext.name) {
                     // Find model by name
                     const modelRecords = await db
@@ -701,7 +352,8 @@ const validateProperty = xstate.fromCallback(({ sendBack, input: { context } })
             // Brief wait so trackPendingWrite from ModelProperty.create() has time to run (it's in setTimeout(0))
             await new Promise((r) => setTimeout(r, 60));
             try {
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
+                const dbMod = await Promise.resolve().then(function () { return require('./index-CXI4VF1H.js'); }).then(function (n) { return n.db; });
+                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 // Try pending write first (property row may not exist yet)
                 if (fullContext.modelName === undefined && schemaFileId) {
                     const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
@@ -759,9 +411,11 @@ const validateProperty = xstate.fromCallback(({ sendBack, input: { context } })
             _originalValues: fullContext._originalValues
         });
         // Use dynamic imports to break circular dependencies
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DUtQUerg.js'); });
+        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+        const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CV9hMg8m.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+        const { Schema } = schemaMod;
         // Validate property structure
         console.log('[validateProperty] Validating property structure...');
         const structureResult = validationService.validatePropertyStructure(fullContext);
@@ -1359,7 +1013,6 @@ class ModelProperty {
             return fallbackIsEdited;
         }
         try {
-            const { eq, and } = await import('drizzle-orm');
             const db = main_cjs.BaseDb.getAppDb();
             if (!db) {
                 return fallbackIsEdited;
@@ -1368,7 +1021,7 @@ class ModelProperty {
             const modelRecords = await db
                 .select({ id: main_cjs.models.id })
                 .from(main_cjs.models)
-                .where(eq(main_cjs.models.name, property.modelName))
+                .where(drizzleOrm.eq(main_cjs.models.name, property.modelName))
                 .limit(1);
             if (modelRecords.length === 0) {
                 return fallbackIsEdited;
@@ -1377,7 +1030,7 @@ class ModelProperty {
             const propertyRecords = await db
                 .select({ isEdited: main_cjs.properties.isEdited })
                 .from(main_cjs.properties)
-                .where(and(eq(main_cjs.properties.name, property.name), eq(main_cjs.properties.modelId, modelRecords[0].id)))
+                .where(drizzleOrm.and(drizzleOrm.eq(main_cjs.properties.name, property.name), drizzleOrm.eq(main_cjs.properties.modelId, modelRecords[0].id)))
                 .limit(1);
             if (propertyRecords.length > 0) {
                 return propertyRecords[0].isEdited ?? false;
@@ -1398,7 +1051,6 @@ class ModelProperty {
             return undefined;
         }
         try {
-            const { eq } = await import('drizzle-orm');
             const db = main_cjs.BaseDb.getAppDb();
             if (!db) {
                 return undefined;
@@ -1406,7 +1058,7 @@ class ModelProperty {
             const refModelRecords = await db
                 .select()
                 .from(main_cjs.models)
-                .where(eq(main_cjs.models.name, refModelName))
+                .where(drizzleOrm.eq(main_cjs.models.name, refModelName))
                 .limit(1);
             if (refModelRecords.length > 0 && refModelRecords[0].id) {
                 return refModelRecords[0].id;
@@ -1427,13 +1079,11 @@ class ModelProperty {
             return undefined;
         }
         try {
-            const { Model } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.Model$1; });
-            const { modelPropertiesToObject } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.model; });
-            const model = await Model.getByNameAsync(property.modelName);
+            const model = await main_cjs.Model.getByNameAsync(property.modelName);
             if (!model || !model.properties || model.properties.length === 0) {
                 return undefined;
             }
-            const schema = modelPropertiesToObject(model.properties);
+            const schema = main_cjs.modelPropertiesToObject(model.properties);
             // Get the schema file value for this property
             const schemaFileValue = schema[property.name];
             if (!schemaFileValue) {
@@ -1477,7 +1127,6 @@ class ModelProperty {
             // Try to get schema name from database first (more reliable)
             if (this.modelId) {
                 try {
-                    const { eq } = await import('drizzle-orm');
                     const db = main_cjs.BaseDb.getAppDb();
                     if (db) {
                         const modelSchemaRecords = await db
@@ -1485,9 +1134,9 @@ class ModelProperty {
                             schemaName: main_cjs.schemas.name,
                         })
                             .from(main_cjs.modelSchemas)
-                            .innerJoin(main_cjs.schemas, eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
-                            .innerJoin(main_cjs.models, eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
-                            .where(eq(main_cjs.models.id, this.modelId))
+                            .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
+                            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                            .where(drizzleOrm.eq(main_cjs.models.id, this.modelId))
                             .limit(1);
                         if (modelSchemaRecords.length > 0) {
                             schemaName = modelSchemaRecords[0].schemaName;
@@ -1500,7 +1149,6 @@ class ModelProperty {
             }
             // Fall back to schema file lookup if database didn't work
             if (!schemaName) {
-                const { getSchemaNameFromModel } = await Promise.resolve().then(function () { return saveToSchema$1; });
                 schemaName = await getSchemaNameFromModel(modelName);
             }
             if (schemaName) {
@@ -1681,8 +1329,7 @@ class ModelProperty {
                         else if (typeof propertyWithId.modelId === 'string') {
                             // modelId is a string (modelFileId), need to convert to database ID
                             try {
-                                const { getModelIdByFileId } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
-                                resolvedModelId = await getModelIdByFileId(propertyWithId.modelId);
+                                resolvedModelId = await main_cjs.getModelIdByFileId(propertyWithId.modelId);
                                 logger(`Converted modelFileId "${propertyWithId.modelId}" to database modelId: ${resolvedModelId}`);
                             }
                             catch (error) {
@@ -1694,10 +1341,9 @@ class ModelProperty {
                     // If we still don't have a modelId, try to resolve it from modelName
                     if (!resolvedModelId && propertyWithId.modelName) {
                         try {
-                            const { getModelId } = await Promise.resolve().then(function () { return require('./index-C3j3m34a.js'); }).then(function (n) { return n.db; });
                             // Get schemaName from context if available
                             const schemaName = snapshot.context._schemaName;
-                            resolvedModelId = await getModelId(propertyWithId.modelName, schemaName);
+                            resolvedModelId = await main_cjs.getModelId(propertyWithId.modelName, schemaName);
                             logger(`Resolved modelId for model "${propertyWithId.modelName}": ${resolvedModelId}`);
                         }
                         catch (error) {
@@ -1803,7 +1449,6 @@ class ModelProperty {
             return cachedInstance;
         }
         // Query database to get property data from ID
-        const { eq } = await import('drizzle-orm');
         const db = main_cjs.BaseDb.getAppDb();
         console.log('db', !!db);
         if (!db) {
@@ -1818,7 +1463,7 @@ class ModelProperty {
         const propertyRecords = await db
             .select()
             .from(main_cjs.properties)
-            .where(eq(main_cjs.properties.schemaFileId, propertyFileId))
+            .where(drizzleOrm.eq(main_cjs.properties.schemaFileId, propertyFileId))
             .limit(1);
         console.log('propertyRecords', propertyRecords);
         if (propertyRecords.length === 0) {
@@ -1829,7 +1474,7 @@ class ModelProperty {
         const modelRecords = await db
             .select({ name: main_cjs.models.name })
             .from(main_cjs.models)
-            .where(eq(main_cjs.models.id, propertyRecord.modelId))
+            .where(drizzleOrm.eq(main_cjs.models.id, propertyRecord.modelId))
             .limit(1);
         if (modelRecords.length === 0) {
             return undefined;
@@ -1854,7 +1499,7 @@ class ModelProperty {
             const refModelRecords = await db
                 .select({ name: main_cjs.models.name })
                 .from(main_cjs.models)
-                .where(eq(main_cjs.models.id, propertyRecord.refModelId))
+                .where(drizzleOrm.eq(main_cjs.models.id, propertyRecord.refModelId))
                 .limit(1);
             if (refModelRecords.length > 0) {
                 propertyData.refModelName = refModelRecords[0].name;
@@ -2106,8 +1751,7 @@ class ModelProperty {
                     }
                 }
                 if (schemaName) {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CV9hMg8m.js'); });
-                    const schema = Schema.create(schemaName, { waitForReady: false });
+                    const schema = Schema.Schema.create(schemaName, { waitForReady: false });
                     const snapshot = schema.getService().getSnapshot();
                     const schemaContext = snapshot.context;
                     if (schemaContext.models?.[modelName]?.properties?.[propertyName]) {
@@ -2133,8 +1777,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 exports.ModelProperty = ModelProperty;
-exports.ModelProperty$1 = ModelProperty$1;
-exports.convertPropertyToSchemaUpdate = convertPropertyToSchemaUpdate;
-exports.updateModelProperties = updateModelProperties;
-exports.writeFullSchemaNewVersion = writeFullSchemaNewVersion;
-//# sourceMappingURL=ModelProperty-BRKRREYP.js.map
+//# sourceMappingURL=ModelProperty-B4pV91tc.js.map