@seedprotocol/sdk 0.7.8 → 0.7.9-next.1177.ga3e08ed

package/dist/{errors-rIWK7gwJ.js → errors-D1zHAqjr.js}

@@ -1,9 +1,9 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { G as BaseDb, t as models, w as properties, aj as generateId, aN as isInternalSchema, aO as writeModelToDb, aP as writePropertyToDb, aQ as addSchemaToDb, r as modelSchemas, B as schemas, I as AmbiguousModelError, aR as renameModelInDb, aS as currentNameMatchLevels, a as TProperty } from './index-C0SetTd1.js';
+import { L as BaseDb, p as models, E as properties, ad as generateId, aF as isInternalSchema, aG as writeModelToDb, aH as writePropertyToDb, z as modelSchemas, J as schemas, A as AmbiguousModelError, aI as renameModelInDb, aJ as currentNameMatchLevels, a as TProperty } from './index-Dx_GTdyQ.js';
 import { eq, and, isNull, or } from 'drizzle-orm';
 import debug from 'debug';
-import { P as isActorStopped, ak as ActorKeyedState, C as waitForEntityIdle, Q as DEFAULT_READY_TIMEOUT_MS, R as createReactiveProxy, T as findEntity, X as ClientManagerState, I as Item, al as clearDestroySubscriptions, U as forceRemoveFromCaches, am as unloadEntity, V as runDestroyLifecycle } from './Item-CjTEShfk.js';
-import { z as getClient } from './ClientManager-B1r_8P5Z.js';
+import { L as isActorStopped, aj as ActorKeyedState, B as waitForEntityIdle, N as DEFAULT_READY_TIMEOUT_MS, P as createReactiveProxy, R as findEntity, W as ClientManagerState, I as Item, ak as clearDestroySubscriptions, S as forceRemoveFromCaches, al as unloadEntity, T as runDestroyLifecycle } from './Item-0oDoTPhi.js';
+import { v as getClient } from './ClientManager-GZfXErDX.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 import { localNamesInBestMatchTier } from '@seedprotocol/eas';
 import { Type } from '@sinclair/typebox';
@@ -19,7 +19,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-C3749Wjq.js');
+        const mod = await import('./ModelProperty-i5flwzQG.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -85,11 +85,11 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                 if (!modelRecord) {
                     // Model names are only unique per schema: prefer this schema's row, and otherwise only
                     // consider same-name rows that no schema claims yet (never another schema's model).
-                    const _mod_0 = await import('./index-C0SetTd1.js');
-                    const _ns_0 = _mod_0.bm;
+                    const _mod_0 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_0 = _mod_0.bd;
                     const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./index-C0SetTd1.js');
-                    const _ns_1 = _mod_1.bl;
+                    const _mod_1 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_1 = _mod_1.bc;
                     const { schemas: schemasTable } = _ns_1;
                     let dbModels = await db
                         .select({
@@ -236,8 +236,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_2 = await import('./Schema-CX9CTtho.js');
-            const _ns_2 = _mod_2.b;
+            const _mod_2 = await import('./Schema-PFZwG9Nl.js');
+            const _ns_2 = _mod_2.a;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
             // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
@@ -387,12 +387,12 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_3 = await import('./index-C0SetTd1.js');
-                        const _ns_3 = _mod_3.bm;
+                        const _mod_3 = await import('./index-Dx_GTdyQ.js');
+                        const _ns_3 = _mod_3.bd;
                         const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./index-C0SetTd1.js');
-                        const _ns_4 = _mod_4.bl;
+                        const _mod_4 = await import('./index-Dx_GTdyQ.js');
+                        const _ns_4 = _mod_4.bc;
                         const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
@@ -487,8 +487,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_5 = await import('./Schema-CX9CTtho.js');
-            const _ns_5 = _mod_5.b;
+            const _mod_5 = await import('./Schema-PFZwG9Nl.js');
+            const _ns_5 = _mod_5.a;
             const schemaMod = _ns_5;
             const { Schema } = schemaMod;
             if (!isActorStopped(self)) {
@@ -535,11 +535,11 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-T5mqnY8q.js');
+            const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-CX9CTtho.js');
-            const _ns_6 = _mod_6.b;
+            const _mod_6 = await import('./Schema-PFZwG9Nl.js');
+            const _ns_6 = _mod_6.a;
             const schemaMod = _ns_6;
             const { Schema } = schemaMod;
             // Validate model structure
@@ -655,7 +655,7 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
             return;
         }
         logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-C3749Wjq.js');
+        const mod = await import('./ModelProperty-i5flwzQG.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -680,8 +680,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                 : undefined;
             // Otherwise use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const _mod_7 = await import('./index-C0SetTd1.js');
-            const _ns_7 = _mod_7.bq;
+            const _mod_7 = await import('./index-Dx_GTdyQ.js');
+            const _ns_7 = _mod_7.bh;
             const { generateId } = _ns_7;
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -698,8 +698,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                     }
                     else if (refModelName) {
                         // Fallback: resolve the ref by name within this model's schema
-                        const _mod_8 = await import('./index-C0SetTd1.js');
-                        const _ns_8 = _mod_8.bn;
+                        const _mod_8 = await import('./index-Dx_GTdyQ.js');
+                        const _ns_8 = _mod_8.be;
                         const { resolveModelRecord } = _ns_8;
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
@@ -869,8 +869,8 @@ const validateEntity = fromPromise(async ({ input }) => {
     const evictionEpoch = currentEvictionEpoch();
     /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
     const schemaForValidation = async (schemaName) => {
-        const _mod_9 = await import('./Schema-CX9CTtho.js');
-        const _ns_9 = _mod_9.b;
+        const _mod_9 = await import('./Schema-PFZwG9Nl.js');
+        const _ns_9 = _mod_9.a;
         const { Schema } = _ns_9;
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
             throw new Error(`Schema "${schemaName}" was evicted during validation`);
@@ -887,7 +887,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-T5mqnY8q.js');
+                const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -937,7 +937,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-T5mqnY8q.js');
+                const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -975,19 +975,6 @@ const validateEntity = fromPromise(async ({ input }) => {
                     }
                 }
             }
-            else if (entityInput.entityType === 'schema') {
-                // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-T5mqnY8q.js');
-                const { SchemaValidationService } = validationServiceMod;
-                const validationService = new SchemaValidationService();
-                const schemaResult = validationService.validateSchema(entityInput.entityData);
-                if (!schemaResult.isValid) {
-                    result = {
-                        isValid: false,
-                        errors: schemaResult.errors,
-                    };
-                }
-            }
             // Return the result - fromPromise will automatically put this in event.output
             const completeMsg = `[validateEntity] Validation complete: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
             logger$4(completeMsg);
@@ -1065,7 +1052,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-C3749Wjq.js');
+                    const mod = await import('./ModelProperty-i5flwzQG.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1093,11 +1080,6 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 await writePropertyToDb(input.entityId, dataToWrite);
                 output = input.entityData;
             }
-            else if (input.entityType === 'schema') {
-                const schemaRecord = await addSchemaToDb(input.entityData, input.entityId, // schemaFileId (string)
-                input.entityData.schemaData, input.entityData.isDraft);
-                output = { ...input.entityData, _dbId: schemaRecord.id }; // Store as _dbId (database integer ID)
-            }
             else {
                 throw new Error(`Unknown entity type: ${input.entityType}`);
             }
@@ -1154,9 +1136,7 @@ const writeProcessMachine = setup({
         entityId: input.entityId,
         entityData: input.entityData || {},
         validationErrors: [],
-        writeStatus: 'idle',
         error: null,
-        retryCount: 0,
         pendingWrite: null,
     }),
     states: {
@@ -1170,7 +1150,6 @@ const writeProcessMachine = setup({
                                 data: event.data,
                                 timestamp: Date.now(),
                             }),
-                            writeStatus: 'validating',
                         }),
                         ({ event, context }) => {
                             logger$2(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
@@ -1225,7 +1204,6 @@ const writeProcessMachine = setup({
                         actions: [
                             assign({
                                 validationErrors: [],
-                                writeStatus: 'writing',
                             }),
                             ({ context }) => {
                                 const msg = `[validating] Validation passed, transitioning to writing for ${context.entityType} "${context.entityId}"`;
@@ -1241,7 +1219,6 @@ const writeProcessMachine = setup({
                                     const result = event.output;
                                     return result.errors || [];
                                 },
-                                writeStatus: 'error',
                                 error: ({ event }) => {
                                     const result = event.output;
                                     return new Error(`Validation failed: ${result.errors.map(e => e.message).join(', ')}`);
@@ -1259,7 +1236,6 @@ const writeProcessMachine = setup({
                     actions: [
                         assign({
                             error: ({ event }) => event.error instanceof Error ? event.error : new Error(String(event.error)),
-                            writeStatus: 'error',
                         }),
                         ({ context, event }) => {
                             const errorMsg = `[validating] Validation error for ${context.entityType} "${context.entityId}": ${event.error}`;
@@ -1269,9 +1245,6 @@ const writeProcessMachine = setup({
                     ],
                 },
             },
-            on: {
-                reset: 'idle',
-            },
         },
         writing: {
             invoke: {
@@ -1292,7 +1265,6 @@ const writeProcessMachine = setup({
                     target: 'success',
                     actions: [
                         assign({
-                            writeStatus: 'success',
                             pendingWrite: null,
                             entityData: ({ context, event }) => {
                                 // Update entityData with any returned data from write
@@ -1309,8 +1281,6 @@ const writeProcessMachine = setup({
                     actions: [
                         assign({
                             error: ({ event }) => event.error instanceof Error ? event.error : new Error(String(event.error)),
-                            writeStatus: 'error',
-                            retryCount: ({ context }) => context.retryCount + 1,
                         }),
                         ({ context, event }) => {
                             const errorMsg = `[writing] Write error for ${context.entityType} "${context.entityId}": ${event.error}`;
@@ -1320,40 +1290,14 @@ const writeProcessMachine = setup({
                         },
                     ],
                 },
-                reset: 'idle',
             },
         },
         success: {
             after: {
                 2000: { target: 'idle' }, // Auto-reset after 2s
             },
-            on: {
-                reset: 'idle',
-            },
-            entry: assign({
-                writeStatus: 'success',
-            }),
-        },
-        error: {
-            on: {
-                retry: {
-                    target: 'validating',
-                    guard: ({ context }) => context.retryCount < 3,
-                    actions: assign({
-                        error: null,
-                    }),
-                },
-                revert: {
-                    target: 'idle',
-                    actions: assign({
-                        pendingWrite: null,
-                        writeStatus: 'idle',
-                        error: null,
-                    }),
-                },
-                reset: 'idle',
-            },
         },
+        error: {},
     },
 });
 
@@ -1459,7 +1403,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-C3749Wjq.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-i5flwzQG.js').then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
@@ -1996,7 +1940,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-C3749Wjq.js')
+const modelPropertyImportPromise = import('./ModelProperty-i5flwzQG.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -2475,9 +2419,13 @@ class Model {
         // If schema provided, trigger write process instead of registration
         // When schemaName is passed as string (e.g. useCreateModel), we must trigger write so runtime-created
         // models get persisted to DB and show up in useModels (which queries the database).
+        const hasProperties = !!options?.properties && Object.keys(options.properties).length > 0;
         const shouldTriggerWrite = (registerWithSchema && schemaInstance) ||
-            (options?.properties && Object.keys(options.properties).length > 0) ||
+            hasProperties ||
             typeof schemaNameOrSchema === 'string';
+        // Every DB load (createById, getByNameAsync, ...) also passes a string schema and no properties.
+        // Such a model adopts its existing row: writing it again rewrote each property row and cleared is_edited.
+        const adoptExistingRow = !!options?.persistedBy || (typeof schemaNameOrSchema === 'string' && !hasProperties);
         if (shouldTriggerWrite) {
             queueMicrotask(async () => {
                 try {
@@ -2506,7 +2454,7 @@ class Model {
                         failPropertyCreation('the model was unloaded');
                         return;
                     }
-                    if (options?.persistedBy && (await Model.adoptPersistedRow(proxiedInstance))) {
+                    if (adoptExistingRow && (await Model.adoptPersistedRow(proxiedInstance))) {
                         return;
                     }
                     // Only write if validation passed (model is in idle state, not error)
@@ -2973,8 +2921,8 @@ class Model {
             const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
                 // Query model by name (throws AmbiguousModelError when several schemas define it)
-                const _mod_10 = await import('./index-C0SetTd1.js');
-                const _ns_10 = _mod_10.bn;
+                const _mod_10 = await import('./index-Dx_GTdyQ.js');
+                const _ns_10 = _mod_10.be;
                 const { resolveModelRecord } = _ns_10;
                 const resolved = await resolveModelRecord(modelName, {}, db);
                 if (!resolved?.schemaFileId) {
@@ -3733,7 +3681,7 @@ class Model {
                         .limit(1);
                     if (modelRecords.length > 0) {
                         const modelId = modelRecords[0].id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-Bo_pky-R.js');
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-DXFYSHRR.js');
                         await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
                         await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
                         await db
@@ -3744,8 +3692,8 @@ class Model {
                 }
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_11 = await import('./Schema-CX9CTtho.js');
-                    const _ns_11 = _mod_11.b;
+                    const _mod_11 = await import('./Schema-PFZwG9Nl.js');
+                    const _ns_11 = _mod_11.a;
                     const { Schema } = _ns_11;
                     const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
                     const schemaContext = schema.getService().getSnapshot().context;
@@ -3788,8 +3736,8 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_12 = await import('./index-C0SetTd1.js');
-                        const _ns_12 = _mod_12.bn;
+                        const _mod_12 = await import('./index-Dx_GTdyQ.js');
+                        const _ns_12 = _mod_12.be;
                         const { resolveModelRecord } = _ns_12;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
@@ -4055,4 +4003,4 @@ var errors = /*#__PURE__*/Object.freeze({
 });
 
 export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, ItemCreateError as d, setupEntityLiveQuery as e, finishSchemaDestroy as f, getDraftSaveError as g, writeToDatabase$1 as h, Model$1 as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
-//# sourceMappingURL=errors-rIWK7gwJ.js.map
+//# sourceMappingURL=errors-D1zHAqjr.js.map