@seedprotocol/sdk 0.4.1 → 0.4.3

package/dist/services/publish/actors/validateItemData.js

@@ -1,18 +0,0 @@
-import { fromCallback } from 'xstate';
-
-const validateItemData = fromCallback(({ sendBack, input: { context } }) => {
-    const _validateItemData = async () => {
-        if (context && context.localId) {
-            return true;
-        }
-        return false;
-    };
-    _validateItemData().then((isValid) => {
-        if (isValid) {
-            sendBack({ type: 'validateItemDataSuccess' });
-        }
-    });
-});
-
-export { validateItemData };
-//# sourceMappingURL=validateItemData.js.map

package/dist/services/publish/actors/validateItemData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateItemData.js","sources":["../../../../../src/services/publish/actors/validateItemData.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport { FromCallbackInput, PublishMachineContext } from '@/types'\n\nexport const validateItemData = fromCallback<\n  EventObject,\n  FromCallbackInput<PublishMachineContext>\n>(({ sendBack, input: { context } }) => {\n  const _validateItemData = async () => {\n    if (context && context.localId) {\n      return true\n    }\n    return false\n  }\n\n  _validateItemData().then((isValid) => {\n    if (isValid) {\n      sendBack({ type: 'validateItemDataSuccess' })\n    }\n  })\n})\n"],"names":[],"mappings":";;AAGO,MAAM,gBAAgB,GAAG,YAAY,CAG1C,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;AACrC,IAAA,MAAM,iBAAiB,GAAG,YAAW;AACnC,QAAA,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,EAAE;AAC9B,YAAA,OAAO,IAAI;QACb;AACA,QAAA,OAAO,KAAK;AACd,IAAA,CAAC;AAED,IAAA,iBAAiB,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,KAAI;QACnC,IAAI,OAAO,EAAE;AACX,YAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC;QAC/C;AACF,IAAA,CAAC,CAAC;AACJ,CAAC;;;;"}

package/dist/services/publish/publishMachine.js

@@ -1,71 +0,0 @@
-import { setup } from 'xstate';
-import { validateItemData } from './actors/validateItemData.js';
-import { PublishMachineStates } from '../../client/constants.js';
-import { createPublishAttempt } from './actors/createPublishAttempt.js';
-import { updateMachineContext } from '../../helpers/updateMachineContext.js';
-import { preparePublishRequestData } from './actors/preparePublishRequestData.js';
-import { upload } from './actors/upload.js';
-
-const { VALIDATING_ITEM_DATA, CREATING_PUBLISH_ATTEMPT, PREPARING_PUBLISH_REQUEST_DATA, UPLOADING, PUBLISHING, IDLE, } = PublishMachineStates;
-const publishMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        validateItemData,
-        createPublishAttempt,
-        upload,
-        preparePublishRequestData,
-    },
-}).createMachine({
-    id: 'publish',
-    initial: VALIDATING_ITEM_DATA,
-    context: ({ input }) => input,
-    on: {
-        updateContext: updateMachineContext,
-    },
-    states: {
-        [VALIDATING_ITEM_DATA]: {
-            on: {
-                validateItemDataSuccess: [CREATING_PUBLISH_ATTEMPT],
-            },
-            invoke: {
-                src: 'validateItemData',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        [CREATING_PUBLISH_ATTEMPT]: {
-            on: {
-                createPublishAttemptSuccess: [UPLOADING],
-            },
-            invoke: {
-                src: 'createPublishAttempt',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        [UPLOADING]: {
-            on: {
-                uploadingSuccess: [PREPARING_PUBLISH_REQUEST_DATA],
-            },
-            invoke: {
-                src: 'upload',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        [PREPARING_PUBLISH_REQUEST_DATA]: {
-            on: {
-                preparePublishRequestDataSuccess: [UPLOADING],
-            },
-            invoke: {
-                src: 'preparePublishRequestData',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        [PUBLISHING]: {},
-        [IDLE]: {},
-    },
-});
-
-export { publishMachine };
-//# sourceMappingURL=publishMachine.js.map

package/dist/services/publish/publishMachine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publishMachine.js","sources":["../../../../src/services/publish/publishMachine.ts"],"sourcesContent":["import { setup } from 'xstate'\nimport { validateItemData } from './actors/validateItemData'\nimport { PublishMachineStates } from '@/client/constants'\nimport { PublishMachineContext } from '@/types'\nimport { createPublishAttempt } from './actors/createPublishAttempt'\nimport { updateMachineContext } from '@/helpers/updateMachineContext'\nimport { preparePublishRequestData } from '@/services/publish/actors/preparePublishRequestData'\nimport { upload } from '@/services/publish/actors/upload'\n\nconst {\n  VALIDATING_ITEM_DATA,\n  CREATING_PUBLISH_ATTEMPT,\n  PREPARING_PUBLISH_REQUEST_DATA,\n  UPLOADING,\n  PUBLISHING,\n  IDLE,\n} = PublishMachineStates\n\nexport const publishMachine = setup({\n  types: {\n    context: {} as PublishMachineContext,\n    input: {} as Partial<PublishMachineContext>,\n  },\n  actors: {\n    validateItemData,\n    createPublishAttempt,\n    upload,\n    preparePublishRequestData,\n  },\n}).createMachine({\n  id: 'publish',\n  initial: VALIDATING_ITEM_DATA,\n  context: ({ input }) => input as PublishMachineContext,\n  on: {\n    updateContext: updateMachineContext,\n  },\n  states: {\n    [VALIDATING_ITEM_DATA]: {\n      on: {\n        validateItemDataSuccess: [CREATING_PUBLISH_ATTEMPT],\n      },\n      invoke: {\n        src: 'validateItemData',\n        input: ({ context }) => ({ context }),\n      },\n    },\n    [CREATING_PUBLISH_ATTEMPT]: {\n      on: {\n        createPublishAttemptSuccess: [UPLOADING],\n      },\n      invoke: {\n        src: 'createPublishAttempt',\n        input: ({ context }) => ({ context }),\n      },\n    },\n    [UPLOADING]: {\n      on: {\n        uploadingSuccess: [PREPARING_PUBLISH_REQUEST_DATA],\n      },\n      invoke: {\n        src: 'upload',\n        input: ({ context }) => ({ context }),\n      },\n    },\n    [PREPARING_PUBLISH_REQUEST_DATA]: {\n      on: {\n        preparePublishRequestDataSuccess: [UPLOADING],\n      },\n      invoke: {\n        src: 'preparePublishRequestData',\n        input: ({ context }) => ({ context }),\n      },\n    },\n    [PUBLISHING]: {},\n    [IDLE]: {},\n  },\n})\n"],"names":[],"mappings":";;;;;;;;AASA,MAAM,EACJ,oBAAoB,EACpB,wBAAwB,EACxB,8BAA8B,EAC9B,SAAS,EACT,UAAU,EACV,IAAI,GACL,GAAG,oBAAoB;AAEjB,MAAM,cAAc,GAAG,KAAK,CAAC;AAClC,IAAA,KAAK,EAAE;AACL,QAAA,OAAO,EAAE,EAA2B;AACpC,QAAA,KAAK,EAAE,EAAoC;AAC5C,KAAA;AACD,IAAA,MAAM,EAAE;QACN,gBAAgB;QAChB,oBAAoB;QACpB,MAAM;QACN,yBAAyB;AAC1B,KAAA;CACF,CAAC,CAAC,aAAa,CAAC;AACf,IAAA,EAAE,EAAE,SAAS;AACb,IAAA,OAAO,EAAE,oBAAoB;IAC7B,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,KAA8B;AACtD,IAAA,EAAE,EAAE;AACF,QAAA,aAAa,EAAE,oBAAoB;AACpC,KAAA;AACD,IAAA,MAAM,EAAE;QACN,CAAC,oBAAoB,GAAG;AACtB,YAAA,EAAE,EAAE;gBACF,uBAAuB,EAAE,CAAC,wBAAwB,CAAC;AACpD,aAAA;AACD,YAAA,MAAM,EAAE;AACN,gBAAA,GAAG,EAAE,kBAAkB;AACvB,gBAAA,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AACtC,aAAA;AACF,SAAA;QACD,CAAC,wBAAwB,GAAG;AAC1B,YAAA,EAAE,EAAE;gBACF,2BAA2B,EAAE,CAAC,SAAS,CAAC;AACzC,aAAA;AACD,YAAA,MAAM,EAAE;AACN,gBAAA,GAAG,EAAE,sBAAsB;AAC3B,gBAAA,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AACtC,aAAA;AACF,SAAA;QACD,CAAC,SAAS,GAAG;AACX,YAAA,EAAE,EAAE;gBACF,gBAAgB,EAAE,CAAC,8BAA8B,CAAC;AACnD,aAAA;AACD,YAAA,MAAM,EAAE;AACN,gBAAA,GAAG,EAAE,QAAQ;AACb,gBAAA,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AACtC,aAAA;AACF,SAAA;QACD,CAAC,8BAA8B,GAAG;AAChC,YAAA,EAAE,EAAE;gBACF,gCAAgC,EAAE,CAAC,SAAS,CAAC;AAC9C,aAAA;AACD,YAAA,MAAM,EAAE;AACN,gBAAA,GAAG,EAAE,2BAA2B;AAChC,gBAAA,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AACtC,aAAA;AACF,SAAA;QACD,CAAC,UAAU,GAAG,EAAE;QAChB,CAAC,IAAI,GAAG,EAAE;AACX,KAAA;AACF,CAAA;;;;"}

package/dist/services/write/actors/validateEntity.js

@@ -1,145 +0,0 @@
-import { fromPromise } from 'xstate';
-import debug from 'debug';
-
-const logger = debug('seedSdk:write:validateEntity');
-// @ts-expect-error - XState v5 type inference bug: incorrectly expects ValidateEntityOutput for input
-// The actor correctly expects ValidateEntityInput, but TypeScript infers the wrong type
-const validateEntity = fromPromise(async ({ input }) => {
-    // Type assertion to fix XState v5 type inference bug
-    // Convert through unknown to avoid type overlap error
-    const entityInput = input;
-    const _validate = async () => {
-        try {
-            const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
-            logger(msg);
-            console.log(msg); // Always log to console
-            logger(`[validateEntity] Entity data:`, entityInput.entityData);
-            let result = { isValid: true, errors: [] };
-            if (entityInput.entityType === 'model') {
-                const structureMsg = `[validateEntity] Validating model structure`;
-                logger(structureMsg);
-                console.log(structureMsg); // Always log to console
-                // Use existing Model validation
-                const { SchemaValidationService } = await import('../../../Schema/service/validation/SchemaValidationService.js');
-                const validationService = new SchemaValidationService();
-                // Validate model structure
-                const structureResult = validationService.validateModelStructure(entityInput.entityData);
-                const structureResultMsg = `[validateEntity] Structure validation result: isValid=${structureResult.isValid}, errors=${structureResult.errors?.length || 0}`;
-                logger(structureResultMsg);
-                console.log(structureResultMsg); // Always log to console
-                if (!structureResult.isValid) {
-                    result = {
-                        isValid: false,
-                        errors: structureResult.errors,
-                    };
-                }
-                else {
-                    // If schema name provided, validate against schema
-                    if (entityInput.entityData.schemaName) {
-                        try {
-                            logger(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const { Schema } = await import('../../../Schema/Schema.js');
-                            const schema = Schema.create(entityInput.entityData.schemaName);
-                            const schemaSnapshot = schema.getService().getSnapshot();
-                            const schemaStatus = schemaSnapshot.value;
-                            logger(`[validateEntity] Schema status: ${schemaStatus}`);
-                            if (schemaStatus === 'idle') {
-                                const schemaContext = schemaSnapshot.context;
-                                logger(`[validateEntity] Running validateModelAgainstSchema`);
-                                const schemaResult = validationService.validateModelAgainstSchema(schemaContext, entityInput.entityData.modelName, entityInput.entityData);
-                                logger(`[validateEntity] Schema validation result:`, schemaResult);
-                                if (!schemaResult.isValid) {
-                                    result = {
-                                        isValid: false,
-                                        errors: schemaResult.errors,
-                                    };
-                                }
-                            }
-                            else {
-                                logger(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
-                            }
-                        }
-                        catch (error) {
-                            logger('Error validating model against schema:', error);
-                            // Continue with structure validation only
-                        }
-                    }
-                    else {
-                        logger(`[validateEntity] No schemaName provided, skipping schema validation`);
-                    }
-                }
-            }
-            else if (entityInput.entityType === 'modelProperty') {
-                // Use existing ModelProperty validation
-                const { SchemaValidationService } = await import('../../../Schema/service/validation/SchemaValidationService.js');
-                const validationService = new SchemaValidationService();
-                // Validate property structure
-                const structureResult = validationService.validatePropertyStructure(entityInput.entityData);
-                if (!structureResult.isValid) {
-                    result = {
-                        isValid: false,
-                        errors: structureResult.errors,
-                    };
-                }
-                else {
-                    // If schema name and model name provided, validate against schema
-                    if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
-                        try {
-                            const { Schema } = await import('../../../Schema/Schema.js');
-                            const schema = Schema.create(entityInput.entityData._schemaName);
-                            const schemaSnapshot = schema.getService().getSnapshot();
-                            const schemaStatus = schemaSnapshot.value;
-                            if (schemaStatus === 'idle') {
-                                const schemaContext = schemaSnapshot.context;
-                                if (schemaContext.models && Object.keys(schemaContext.models).length > 0) {
-                                    const schemaResult = validationService.validateProperty(schemaContext, entityInput.entityData.modelName, entityInput.entityData.name || '', entityInput.entityData);
-                                    if (!schemaResult.isValid) {
-                                        result = {
-                                            isValid: false,
-                                            errors: schemaResult.errors,
-                                        };
-                                    }
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logger('Error validating property against schema:', error);
-                            // Continue with structure validation only
-                        }
-                    }
-                }
-            }
-            else if (entityInput.entityType === 'schema') {
-                // Schema validation - use existing validation
-                const { SchemaValidationService } = await import('../../../Schema/service/validation/SchemaValidationService.js');
-                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(completeMsg);
-            console.log(completeMsg); // Always log to console
-            logger(`[validateEntity] Validation complete:`, result);
-            console.log(`[validateEntity] Returning result:`, result);
-            return result;
-        }
-        catch (error) {
-            const errorMsg = `[validateEntity] Error in validateEntity: ${error instanceof Error ? error.message : String(error)}`;
-            logger(errorMsg);
-            console.error(errorMsg, error); // Always log to console
-            logger('Error in validateEntity:', error);
-            // Throw error - fromPromise will automatically create error.platform event
-            throw error;
-        }
-    };
-    return await _validate();
-});
-
-export { validateEntity };
-//# sourceMappingURL=validateEntity.js.map

package/dist/services/write/actors/validateEntity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateEntity.js","sources":["../../../../../src/services/write/actors/validateEntity.ts"],"sourcesContent":["import { fromPromise } from 'xstate'\nimport { ValidationError } from '@/Schema/validation'\nimport debug from 'debug'\n\nconst logger = debug('seedSdk:write:validateEntity')\n\nexport type ValidateEntityInput = {\n  entityType: 'model' | 'modelProperty' | 'schema'\n  entityData: any\n}\n\ntype ValidateEntityOutput = {\n  isValid: boolean\n  errors: ValidationError[]\n}\n\n// @ts-expect-error - XState v5 type inference bug: incorrectly expects ValidateEntityOutput for input\n// The actor correctly expects ValidateEntityInput, but TypeScript infers the wrong type\nexport const validateEntity = fromPromise<\n  ValidateEntityInput,\n  ValidateEntityOutput\n>(async ({ input }) => {\n  // Type assertion to fix XState v5 type inference bug\n  // Convert through unknown to avoid type overlap error\n  const entityInput = input as unknown as ValidateEntityInput\n  \n  const _validate = async (): Promise<ValidateEntityOutput> => {\n    try {\n      const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`\n      logger(msg)\n      console.log(msg) // Always log to console\n      logger(`[validateEntity] Entity data:`, entityInput.entityData)\n      let result: ValidateEntityOutput = { isValid: true, errors: [] }\n\n      if (entityInput.entityType === 'model') {\n        const structureMsg = `[validateEntity] Validating model structure`\n        logger(structureMsg)\n        console.log(structureMsg) // Always log to console\n        // Use existing Model validation\n        const { SchemaValidationService } = await import('@/Schema/service/validation/SchemaValidationService')\n        const validationService = new SchemaValidationService()\n        \n        // Validate model structure\n        const structureResult = validationService.validateModelStructure(entityInput.entityData)\n        const structureResultMsg = `[validateEntity] Structure validation result: isValid=${structureResult.isValid}, errors=${structureResult.errors?.length || 0}`\n        logger(structureResultMsg)\n        console.log(structureResultMsg) // Always log to console\n        \n        if (!structureResult.isValid) {\n          result = {\n            isValid: false,\n            errors: structureResult.errors,\n          }\n        } else {\n          // If schema name provided, validate against schema\n          if (entityInput.entityData.schemaName) {\n            try {\n              logger(`[validateEntity] Validating model against schema \"${entityInput.entityData.schemaName}\"`)\n              const { Schema } = await import('@/Schema/Schema')\n              const schema = Schema.create(entityInput.entityData.schemaName)\n              const schemaSnapshot = schema.getService().getSnapshot()\n              const schemaStatus = schemaSnapshot.value\n              logger(`[validateEntity] Schema status: ${schemaStatus}`)\n              \n              if (schemaStatus === 'idle') {\n                const schemaContext = schemaSnapshot.context\n                logger(`[validateEntity] Running validateModelAgainstSchema`)\n                const schemaResult = validationService.validateModelAgainstSchema(\n                  schemaContext,\n                  entityInput.entityData.modelName,\n                  entityInput.entityData\n                )\n                logger(`[validateEntity] Schema validation result:`, schemaResult)\n                \n                if (!schemaResult.isValid) {\n                  result = {\n                    isValid: false,\n                    errors: schemaResult.errors,\n                  }\n                }\n              } else {\n                logger(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`)\n              }\n            } catch (error) {\n              logger('Error validating model against schema:', error)\n              // Continue with structure validation only\n            }\n          } else {\n            logger(`[validateEntity] No schemaName provided, skipping schema validation`)\n          }\n        }\n      } else if (entityInput.entityType === 'modelProperty') {\n        // Use existing ModelProperty validation\n        const { SchemaValidationService } = await import('@/Schema/service/validation/SchemaValidationService')\n        const validationService = new SchemaValidationService()\n        \n        // Validate property structure\n        const structureResult = validationService.validatePropertyStructure(entityInput.entityData)\n        \n        if (!structureResult.isValid) {\n          result = {\n            isValid: false,\n            errors: structureResult.errors,\n          }\n        } else {\n          // If schema name and model name provided, validate against schema\n          if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {\n            try {\n              const { Schema } = await import('@/Schema/Schema')\n              const schema = Schema.create(entityInput.entityData._schemaName)\n              const schemaSnapshot = schema.getService().getSnapshot()\n              const schemaStatus = schemaSnapshot.value\n              \n              if (schemaStatus === 'idle') {\n                const schemaContext = schemaSnapshot.context\n                \n                if (schemaContext.models && Object.keys(schemaContext.models).length > 0) {\n                  const schemaResult = validationService.validateProperty(\n                    schemaContext,\n                    entityInput.entityData.modelName,\n                    entityInput.entityData.name || '',\n                    entityInput.entityData\n                  )\n                  \n                  if (!schemaResult.isValid) {\n                    result = {\n                      isValid: false,\n                      errors: schemaResult.errors,\n                    }\n                  }\n                }\n              }\n            } catch (error) {\n              logger('Error validating property against schema:', error)\n              // Continue with structure validation only\n            }\n          }\n        }\n      } else if (entityInput.entityType === 'schema') {\n        // Schema validation - use existing validation\n        const { SchemaValidationService } = await import('@/Schema/service/validation/SchemaValidationService')\n        const validationService = new SchemaValidationService()\n        \n        const schemaResult = validationService.validateSchema(entityInput.entityData)\n        \n        if (!schemaResult.isValid) {\n          result = {\n            isValid: false,\n            errors: schemaResult.errors,\n          }\n        }\n      }\n\n      // Return the result - fromPromise will automatically put this in event.output\n      const completeMsg = `[validateEntity] Validation complete: isValid=${result.isValid}, errors=${result.errors?.length || 0}`\n      logger(completeMsg)\n      console.log(completeMsg) // Always log to console\n      logger(`[validateEntity] Validation complete:`, result)\n      console.log(`[validateEntity] Returning result:`, result)\n      return result\n    } catch (error) {\n      const errorMsg = `[validateEntity] Error in validateEntity: ${error instanceof Error ? error.message : String(error)}`\n      logger(errorMsg)\n      console.error(errorMsg, error) // Always log to console\n      logger('Error in validateEntity:', error)\n      // Throw error - fromPromise will automatically create error.platform event\n      throw error\n    }\n  }\n\n  return await _validate()\n})\n\n"],"names":[],"mappings":"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"}

package/dist/services/write/actors/writeToDatabase.js

@@ -1,91 +0,0 @@
-import { fromCallback } from 'xstate';
-import debug from 'debug';
-
-const logger = debug('seedSdk:write:writeToDatabase');
-const writeToDatabase = fromCallback(({ sendBack, input }) => {
-    const _write = async () => {
-        try {
-            const { BaseDb } = await import('../../../db/Db/BaseDb.js');
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not available');
-            }
-            let output = input.entityData;
-            if (input.entityType === 'model') {
-                const { writeModelToDb } = await import('../../../helpers/db.js');
-                const { BaseDb } = await import('../../../db/Db/BaseDb.js');
-                const { models: modelsTable } = await import('../../../seedSchema/ModelSchema.js');
-                const { eq } = await import('drizzle-orm');
-                const writeMsg = `Writing model to database: ${input.entityData.modelName} (schemaId: ${input.entityData.schemaId})`;
-                logger(writeMsg);
-                console.log(writeMsg); // Always log to console
-                logger(`Writing model to database:`, {
-                    modelFileId: input.entityId,
-                    modelName: input.entityData.modelName,
-                    schemaId: input.entityData.schemaId,
-                });
-                await writeModelToDb(input.entityId, input.entityData);
-                // Get _dbId from database after write
-                const db = BaseDb.getAppDb();
-                if (db) {
-                    const modelRecords = await db
-                        .select({ id: modelsTable.id })
-                        .from(modelsTable)
-                        .where(eq(modelsTable.schemaFileId, input.entityId)) // entityId is now the schemaFileId (string)
-                        .limit(1);
-                    if (modelRecords.length > 0 && modelRecords[0].id) {
-                        output = { ...input.entityData, _dbId: modelRecords[0].id }; // Store as _dbId (database integer ID)
-                    }
-                    else {
-                        output = input.entityData;
-                    }
-                }
-                else {
-                    output = input.entityData;
-                }
-                const successMsg = `Successfully wrote model "${input.entityData.modelName}" to database`;
-                logger(successMsg);
-                console.log(successMsg); // Always log to console
-            }
-            else if (input.entityType === 'modelProperty') {
-                const { writePropertyToDb } = await import('../../../helpers/db.js');
-                await writePropertyToDb(input.entityId, input.entityData);
-                output = input.entityData;
-            }
-            else if (input.entityType === 'schema') {
-                const { addSchemaToDb } = await import('../../../helpers/db.js');
-                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}`);
-            }
-            // Send success event explicitly - callback actors don't trigger onDone
-            sendBack({
-                type: 'writeSuccess',
-                output,
-            });
-        }
-        catch (error) {
-            logger('Error in writeToDatabase:', error);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _write().catch((error) => {
-        logger('Error in writeToDatabase promise:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-export { writeToDatabase };
-//# sourceMappingURL=writeToDatabase.js.map

package/dist/services/write/actors/writeToDatabase.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"writeToDatabase.js","sources":["../../../../../src/services/write/actors/writeToDatabase.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport debug from 'debug'\n\nconst logger = debug('seedSdk:write:writeToDatabase')\n\ntype WriteToDatabaseInput = {\n  entityType: 'model' | 'modelProperty' | 'schema'\n  entityId: string\n  entityData: any\n}\n\nexport const writeToDatabase = fromCallback<\n  EventObject,\n  WriteToDatabaseInput\n>(({ sendBack, input }) => {\n  const _write = async (): Promise<void> => {\n    try {\n      const { BaseDb } = await import('@/db/Db/BaseDb')\n      const db = BaseDb.getAppDb()\n      \n      if (!db) {\n        throw new Error('Database not available')\n      }\n\n      let output: any = input.entityData\n\n      if (input.entityType === 'model') {\n        const { writeModelToDb } = await import('@/helpers/db')\n        const { BaseDb } = await import('@/db/Db/BaseDb')\n        const { models: modelsTable } = await import('@/seedSchema/ModelSchema')\n        const { eq } = await import('drizzle-orm')\n        const writeMsg = `Writing model to database: ${input.entityData.modelName} (schemaId: ${input.entityData.schemaId})`\n        logger(writeMsg)\n        console.log(writeMsg) // Always log to console\n        logger(`Writing model to database:`, {\n          modelFileId: input.entityId,\n          modelName: input.entityData.modelName,\n          schemaId: input.entityData.schemaId,\n        })\n        await writeModelToDb(input.entityId, input.entityData)\n        \n        // Get _dbId from database after write\n        const db = BaseDb.getAppDb()\n        if (db) {\n          const modelRecords = await db\n            .select({ id: modelsTable.id })\n            .from(modelsTable)\n            .where(eq(modelsTable.schemaFileId, input.entityId)) // entityId is now the schemaFileId (string)\n            .limit(1)\n          \n          if (modelRecords.length > 0 && modelRecords[0].id) {\n            output = { ...input.entityData, _dbId: modelRecords[0].id } // Store as _dbId (database integer ID)\n          } else {\n            output = input.entityData\n          }\n        } else {\n          output = input.entityData\n        }\n        \n        const successMsg = `Successfully wrote model \"${input.entityData.modelName}\" to database`\n        logger(successMsg)\n        console.log(successMsg) // Always log to console\n      } else if (input.entityType === 'modelProperty') {\n        const { writePropertyToDb } = await import('@/helpers/db')\n        await writePropertyToDb(input.entityId, input.entityData)\n        output = input.entityData\n      } else if (input.entityType === 'schema') {\n        const { addSchemaToDb } = await import('@/helpers/db')\n        const schemaRecord = await addSchemaToDb(\n          input.entityData,\n          input.entityId, // schemaFileId (string)\n          input.entityData.schemaData,\n          input.entityData.isDraft\n        )\n        output = { ...input.entityData, _dbId: schemaRecord.id } // Store as _dbId (database integer ID)\n      } else {\n        throw new Error(`Unknown entity type: ${input.entityType}`)\n      }\n\n      // Send success event explicitly - callback actors don't trigger onDone\n      sendBack({\n        type: 'writeSuccess',\n        output,\n      })\n    } catch (error) {\n      logger('Error in writeToDatabase:', error)\n      sendBack({\n        type: 'writeError',\n        error: error instanceof Error ? error : new Error(String(error)),\n      })\n    }\n  }\n\n  _write().catch((error) => {\n    logger('Error in writeToDatabase promise:', error)\n    sendBack({\n      type: 'writeError',\n      error: error instanceof Error ? error : new Error(String(error)),\n    })\n  })\n\n  return () => {\n    // Cleanup function (optional)\n  }\n})\n\n"],"names":[],"mappings":"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"}

package/dist/services/write/writeProcessMachine.js

@@ -1,233 +0,0 @@
-import { setup, assign } from 'xstate';
-import { validateEntity } from './actors/validateEntity.js';
-import { writeToDatabase } from './actors/writeToDatabase.js';
-import debug from 'debug';
-
-const logger = debug('seedSdk:write:writeProcessMachine');
-const writeProcessMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        validateEntity,
-        writeToDatabase,
-    },
-}).createMachine({
-    id: 'writeProcess',
-    initial: 'idle',
-    context: ({ input }) => ({
-        entityType: input.entityType,
-        entityId: input.entityId,
-        entityData: input.entityData || {},
-        validationErrors: [],
-        writeStatus: 'idle',
-        error: null,
-        retryCount: 0,
-        pendingWrite: null,
-    }),
-    states: {
-        idle: {
-            on: {
-                startWrite: {
-                    target: 'validating',
-                    actions: [
-                        assign({
-                            pendingWrite: ({ event }) => ({
-                                data: event.data,
-                                timestamp: Date.now(),
-                            }),
-                            writeStatus: 'validating',
-                        }),
-                        ({ event, context }) => {
-                            logger(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
-                            logger(`[startWrite] Data:`, event.data);
-                        },
-                    ],
-                },
-            },
-        },
-        validating: {
-            entry: ({ context }) => {
-                const msg = `[validating] Entering validating state for ${context.entityType} "${context.entityId}"`;
-                logger(msg);
-                console.log(msg); // Always log to console
-                logger(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
-            },
-            // @ts-expect-error - XState v5 type inference bug: incorrectly expects ValidateEntityOutput for input
-            // The actor correctly expects ValidateEntityInput, but TypeScript infers the wrong type
-            invoke: {
-                src: 'validateEntity',
-                input: ({ context }) => {
-                    const entityData = context.pendingWrite?.data || context.entityData;
-                    logger(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
-                    return {
-                        entityType: context.entityType,
-                        entityData,
-                    };
-                },
-                onDone: [
-                    {
-                        target: 'writing',
-                        guard: ({ event }) => {
-                            console.log(`[validating] onDone handler called, event:`, event);
-                            console.log(`[validating] event.output:`, event.output);
-                            // The output might be the result directly, or it might be wrapped in an event
-                            let result;
-                            if (event.output && typeof event.output === 'object' && 'isValid' in event.output) {
-                                result = event.output;
-                            }
-                            else if (event.output && typeof event.output === 'object' && 'type' in event.output) {
-                                // If it's wrapped in an event, extract the result
-                                result = event.output;
-                            }
-                            else {
-                                console.error(`[validating] Unexpected event.output format! Event:`, event);
-                                return false;
-                            }
-                            if (!result || typeof result.isValid !== 'boolean') {
-                                console.error(`[validating] Invalid result format! Result:`, result);
-                                return false;
-                            }
-                            const resultMsg = `[validating] Validation result: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-                            logger(resultMsg);
-                            console.log(resultMsg); // Always log to console
-                            logger(`[validating] Validation result:`, result);
-                            return result.isValid;
-                        },
-                        actions: [
-                            assign({
-                                validationErrors: [],
-                                writeStatus: 'writing',
-                            }),
-                            ({ context }) => {
-                                const msg = `[validating] Validation passed, transitioning to writing for ${context.entityType} "${context.entityId}"`;
-                                logger(msg);
-                                console.log(msg); // Always log to console
-                            },
-                        ],
-                    },
-                    {
-                        target: 'error',
-                        actions: [
-                            assign({
-                                validationErrors: ({ event }) => {
-                                    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(', ')}`);
-                                },
-                            }),
-                            ({ context, event }) => {
-                                const result = event.output;
-                                logger(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
-                            },
-                        ],
-                    },
-                ],
-                onError: {
-                    target: 'error',
-                    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}`;
-                            logger(errorMsg);
-                            console.error(errorMsg, event.error); // Always log to console
-                        },
-                    ],
-                },
-            },
-            on: {
-                reset: 'idle',
-            },
-        },
-        writing: {
-            invoke: {
-                src: 'writeToDatabase',
-                input: ({ context }) => {
-                    const entityData = context.pendingWrite?.data || context.entityData;
-                    logger(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
-                    logger(`[writing] Entity data:`, entityData);
-                    return {
-                        entityType: context.entityType,
-                        entityId: context.entityId,
-                        entityData,
-                    };
-                },
-            },
-            on: {
-                writeSuccess: {
-                    target: 'success',
-                    actions: [
-                        assign({
-                            writeStatus: 'success',
-                            pendingWrite: null,
-                            entityData: ({ context, event }) => {
-                                // Update entityData with any returned data from write
-                                return event.output || context.entityData;
-                            },
-                        }),
-                        ({ context }) => {
-                            logger(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
-                        },
-                    ],
-                },
-                writeError: {
-                    target: 'error',
-                    actions: [
-                        assign({
-                            error: ({ event }) => event.error instanceof Error ? event.error : new Error(String(event.error)),
-                            writeStatus: 'error',
-                            retryCount: ({ context }) => context.retryCount + 1,
-                        }),
-                        ({ context, event }) => {
-                            logger(`[writing] Write error for ${context.entityType} "${context.entityId}":`, event.error);
-                        },
-                    ],
-                },
-                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',
-            },
-        },
-    },
-});
-
-export { writeProcessMachine };
-//# sourceMappingURL=writeProcessMachine.js.map