@seedprotocol/sdk 0.4.2 → 0.4.4

package/dist/Schema/service/schemaMachine.js

@@ -1,667 +0,0 @@
-import { setup, assign } from 'xstate';
-import { loadOrCreateSchema } from './actors/loadOrCreateSchema.js';
-import { validateSchema } from './actors/validateSchema.js';
-import { addModelsMachine } from './addModelsMachine.js';
-import { writeProcessMachine } from '../../services/write/writeProcessMachine.js';
-import { checkExistingSchema } from './actors/checkExistingSchema.js';
-import { writeSchemaToDb } from './actors/writeSchemaToDb.js';
-import { verifySchemaInDb } from './actors/verifySchemaInDb.js';
-import { writeModelsToDb } from './actors/writeModelsToDb.js';
-import { verifyModelsInDb } from './actors/verifyModelsInDb.js';
-import { createModelInstances } from './actors/createModelInstances.js';
-import { verifyModelInstancesInCache } from './actors/verifyModelInstancesInCache.js';
-import { writePropertiesToDb } from './actors/writePropertiesToDb.js';
-import { verifyPropertiesInDb } from './actors/verifyPropertiesInDb.js';
-import { createPropertyInstances } from './actors/createPropertyInstances.js';
-import { verifyPropertyInstancesInCache } from './actors/verifyPropertyInstancesInCache.js';
-
-const schemaMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        loadOrCreateSchema,
-        validateSchema,
-        addModelsMachine,
-        writeProcessMachine,
-        // Staged loading actors
-        checkExistingSchema,
-        writeSchemaToDb,
-        verifySchemaInDb,
-        writeModelsToDb,
-        verifyModelsInDb,
-        createModelInstances,
-        verifyModelInstancesInCache,
-        writePropertiesToDb,
-        verifyPropertiesInDb,
-        createPropertyInstances,
-        verifyPropertyInstancesInCache,
-    },
-    guards: {
-        isSchemaValid: ({ context }) => {
-            return !context._validationErrors || context._validationErrors.length === 0;
-        },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
-    },
-}).createMachine({
-    id: 'schema',
-    initial: 'loading',
-    context: ({ input }) => ({
-        schemaName: input.schemaName,
-        _isDraft: false,
-        _editedProperties: new Set(),
-        _validationErrors: undefined,
-        _liveQueryModelIds: [],
-    }),
-    on: {
-        updateContext: {
-            actions: assign(({ context, event }) => {
-                const newContext = Object.assign({}, context);
-                // Check if this is only updating internal fields
-                Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-                for (let i = 0; i < Object.keys(event).length; i++) {
-                    const key = Object.keys(event)[i];
-                    if (key === 'type') {
-                        continue;
-                    }
-                    if (key in newContext || key.startsWith('_')) {
-                        newContext[key] = event[key];
-                    }
-                }
-                // Clear validation errors on context update (will be re-validated if needed)
-                newContext._validationErrors = undefined;
-                return newContext;
-            }),
-            // Only trigger validation if we're updating non-internal fields
-            guard: ({ event }) => {
-                return !Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-            },
-            target: '.validating',
-        },
-        validateSchema: {
-            target: '.validating',
-        },
-        validationSuccess: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _validationErrors: [],
-            })),
-        },
-        validationError: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _validationErrors: event.errors,
-            })),
-        },
-        markAsDraft: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _isDraft: true,
-                _isEdited: true,
-                _editedProperties: new Set([
-                    ...(context._editedProperties || []),
-                    event.propertyKey,
-                ]),
-            })),
-        },
-        clearDraft: {
-            actions: assign(({ context, event }) => {
-                const newContext = { ...context };
-                newContext._isDraft = false;
-                newContext._isEdited = false;
-                newContext._editedProperties = new Set();
-                // Update conflict detection metadata if provided
-                if (event._dbUpdatedAt !== undefined) {
-                    newContext._dbUpdatedAt = event._dbUpdatedAt;
-                }
-                if (event._dbVersion !== undefined) {
-                    newContext._dbVersion = event._dbVersion;
-                }
-                return newContext;
-            }),
-        },
-    },
-    states: {
-        loading: {
-            initial: 'checkingExisting',
-            states: {
-                // Stage 0: Check for existing schema
-                checkingExisting: {
-                    invoke: {
-                        src: 'checkExistingSchema',
-                        input: ({ context }) => ({ context }),
-                    },
-                    on: {
-                        schemaFound: {
-                            target: '#schema.idle',
-                            actions: assign(({ event }) => {
-                                return {
-                                    schemaName: event.schema.metadata.name,
-                                    $schema: event.schema.$schema,
-                                    version: event.schema.version,
-                                    metadata: event.schema.metadata,
-                                    models: event.schema.models,
-                                    enums: event.schema.enums,
-                                    migrations: event.schema.migrations,
-                                    _isDraft: false,
-                                    _isEdited: event.schemaRecord?.isEdited ?? false,
-                                    _editedProperties: new Set(),
-                                    _validationErrors: undefined,
-                                    id: event.schema.id, // schemaFileId (string)
-                                    _dbId: event.schemaRecord?.id, // Database integer ID
-                                    _loadedAt: event.loadedAt,
-                                    _dbVersion: event.dbVersion,
-                                    _dbUpdatedAt: event.dbUpdatedAt,
-                                    _liveQueryModelIds: event.modelIds || [],
-                                    _schemaRecord: event.schemaRecord,
-                                };
-                            }),
-                        },
-                        schemaNotFound: {
-                            target: 'writingSchema',
-                        },
-                    },
-                },
-                // Stage 1: Write and verify schema
-                writingSchema: {
-                    entry: assign({
-                        _loadingStage: 'writingSchema',
-                    }),
-                    invoke: {
-                        src: 'writeSchemaToDb',
-                        input: ({ context }) => ({
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        schemaWritten: {
-                            target: 'verifyingSchema',
-                            actions: assign({
-                                _schemaRecord: ({ event }) => event.schemaRecord,
-                                id: ({ event }) => event.schema.id, // schemaFileId (string)
-                                _dbId: ({ event }) => event.schemaRecord?.id, // Database integer ID
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingSchema',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingSchema: {
-                    entry: assign({
-                        _loadingStage: 'verifyingSchema',
-                    }),
-                    invoke: {
-                        src: 'verifySchemaInDb',
-                        input: ({ context }) => ({
-                            schemaFileId: context.id,
-                            expectedSchemaId: context._dbId,
-                        }),
-                    },
-                    on: {
-                        schemaVerified: {
-                            target: 'writingModels',
-                            actions: assign({
-                                _dbId: ({ event }) => event.schemaId, // Store database integer ID
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 2: Write and verify models
-                writingModels: {
-                    entry: assign({
-                        _loadingStage: 'writingModels',
-                    }),
-                    invoke: {
-                        src: 'writeModelsToDb',
-                        input: ({ context }) => ({
-                            schema: {
-                                id: context.id,
-                                models: context.models || {},
-                                version: context.version || 1,
-                                metadata: context.metadata || { name: context.schemaName, createdAt: '', updatedAt: '' },
-                            },
-                            schemaRecord: context._schemaRecord,
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        modelsWritten: {
-                            target: 'verifyingModels',
-                            actions: assign({
-                                _modelIds: ({ event }) => event.modelIds,
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingModels',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingModels: {
-                    entry: assign({
-                        _loadingStage: 'verifyingModels',
-                    }),
-                    invoke: {
-                        src: 'verifyModelsInDb',
-                        input: ({ context }) => ({
-                            schemaId: context._dbId,
-                            expectedModelIds: context._modelIds,
-                        }),
-                    },
-                    on: {
-                        modelsVerified: {
-                            target: 'creatingModelInstances',
-                            actions: assign({
-                                _modelIds: ({ event }) => event.modelIds,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 3: Create and verify model instances
-                creatingModelInstances: {
-                    entry: assign({
-                        _loadingStage: 'creatingModelInstances',
-                    }),
-                    invoke: {
-                        src: 'createModelInstances',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        instancesCreated: {
-                            target: 'verifyingModelInstances',
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'creatingModelInstances',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingModelInstances: {
-                    entry: assign({
-                        _loadingStage: 'verifyingModelInstances',
-                    }),
-                    invoke: {
-                        src: 'verifyModelInstancesInCache',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesVerified: {
-                            target: 'writingProperties',
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 4: Write and verify properties
-                writingProperties: {
-                    entry: assign({
-                        _loadingStage: 'writingProperties',
-                    }),
-                    invoke: {
-                        src: 'writePropertiesToDb',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        propertiesWritten: {
-                            target: 'verifyingProperties',
-                            actions: assign({
-                                _propertyIds: ({ event }) => event.propertyIds,
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingProperties',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingProperties: {
-                    entry: assign({
-                        _loadingStage: 'verifyingProperties',
-                    }),
-                    invoke: {
-                        src: 'verifyPropertiesInDb',
-                        input: ({ context }) => ({
-                            modelFileIds: context._modelIds,
-                            expectedPropertyIds: context._propertyIds,
-                        }),
-                    },
-                    on: {
-                        propertiesVerified: {
-                            target: 'creatingPropertyInstances',
-                            actions: assign({
-                                _propertyIds: ({ event }) => event.propertyIds,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 5: Create and verify property instances
-                creatingPropertyInstances: {
-                    entry: assign({
-                        _loadingStage: 'creatingPropertyInstances',
-                    }),
-                    invoke: {
-                        src: 'createPropertyInstances',
-                        input: ({ context }) => ({
-                            propertyIds: context._propertyIds || [],
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesCreated: {
-                            target: 'verifyingPropertyInstances',
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'creatingPropertyInstances',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingPropertyInstances: {
-                    entry: assign({
-                        _loadingStage: 'verifyingPropertyInstances',
-                    }),
-                    invoke: {
-                        src: 'verifyPropertyInstancesInCache',
-                        input: ({ context }) => ({
-                            propertyIds: context._propertyIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesVerified: {
-                            target: '#schema.idle',
-                            actions: assign({
-                                _liveQueryModelIds: ({ context }) => context._modelIds || [],
-                                _loadingStage: undefined,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-            },
-            on: {
-                // Keep backward compatibility with old loadOrCreateSchema (for external callers)
-                loadOrCreateSchemaSuccess: {
-                    target: 'idle',
-                    actions: assign(({ event }) => {
-                        return {
-                            schemaName: event.schema.metadata.name,
-                            $schema: event.schema.$schema,
-                            version: event.schema.version,
-                            metadata: event.schema.metadata,
-                            models: event.schema.models,
-                            enums: event.schema.enums,
-                            migrations: event.schema.migrations,
-                            _isDraft: false,
-                            _editedProperties: new Set(),
-                            _validationErrors: undefined,
-                            id: event.schema.id, // schemaFileId (string)
-                            _dbId: event._dbId, // Database integer ID
-                            _loadedAt: event.loadedAt,
-                            _dbVersion: event.dbVersion,
-                            _dbUpdatedAt: event.dbUpdatedAt,
-                            _liveQueryModelIds: event._liveQueryModelIds || [],
-                        };
-                    }),
-                },
-                loadOrCreateSchemaError: {
-                    target: 'error',
-                },
-            },
-        },
-        idle: {
-            entry: assign({
-                writeProcess: ({ spawn, context }) => {
-                    if (!context.writeProcess && context.id) {
-                        return spawn(writeProcessMachine, {
-                            input: {
-                                entityType: 'schema',
-                                entityId: context.id,
-                                entityData: {
-                                    name: context.schemaName,
-                                    $schema: context.$schema,
-                                    version: context.version,
-                                    metadata: context.metadata,
-                                    models: context.models,
-                                    enums: context.enums,
-                                    migrations: context.migrations,
-                                },
-                            },
-                        });
-                    }
-                    return context.writeProcess;
-                },
-            }),
-            on: {
-                addModels: {
-                    target: 'addingModels',
-                },
-                validateSchema: {
-                    target: 'validating',
-                },
-                reloadFromDb: {
-                    target: 'loading',
-                },
-                requestWrite: {
-                    actions: ({ context, event }) => {
-                        if (context.writeProcess) {
-                            context.writeProcess.send({
-                                type: 'startWrite',
-                                data: event.data,
-                            });
-                        }
-                    },
-                },
-            },
-            always: {
-                guard: 'hasValidationErrors',
-                target: 'validating',
-            },
-        },
-        addingModels: {
-            entry: assign({
-                // Move first pending item to current if not already set
-                _pendingModelAdditions: ({ context, event }) => {
-                    const pending = context._pendingModelAdditions || [];
-                    // If event has models, it's a new request - add to queue if we're already processing
-                    if (event.models) {
-                        return [
-                            ...pending,
-                            {
-                                models: event.models,
-                                timestamp: Date.now(),
-                            },
-                        ];
-                    }
-                    return pending;
-                },
-            }),
-            invoke: {
-                src: 'addModelsMachine',
-                input: ({ context }) => {
-                    // Get models from first item in pending queue, or from context if queue is empty
-                    const pending = context._pendingModelAdditions || [];
-                    const models = pending.length > 0 ? pending[0].models : {};
-                    return {
-                        schemaContext: context,
-                        models,
-                        existingModels: context.models || {},
-                    };
-                },
-                onDone: {
-                    actions: [
-                        assign({
-                            models: ({ context, event }) => {
-                                const addedModels = event.output?.addedModels || {};
-                                return {
-                                    ...(context.models || {}),
-                                    ...addedModels,
-                                };
-                            },
-                            _pendingModelAdditions: ({ context }) => {
-                                // Remove first item from queue (the one we just processed)
-                                const pending = context._pendingModelAdditions || [];
-                                return pending.length > 1 ? pending.slice(1) : undefined;
-                            },
-                        }),
-                        // Trigger validation after models are added
-                        ({ self }) => {
-                            self.send({ type: 'validateSchema' });
-                        },
-                    ],
-                },
-                onError: {
-                    actions: assign({
-                        _modelAdditionErrors: ({ context, event }) => {
-                            const existing = context._modelAdditionErrors || [];
-                            return [
-                                ...existing,
-                                {
-                                    error: event.error instanceof Error ? event.error : new Error(String(event.error)),
-                                    timestamp: Date.now(),
-                                },
-                            ];
-                        },
-                        _pendingModelAdditions: ({ context }) => {
-                            // Remove first item from queue even on error, so we can process next
-                            const pending = context._pendingModelAdditions || [];
-                            return pending.length > 1 ? pending.slice(1) : undefined;
-                        },
-                    }),
-                },
-            },
-            on: {
-                // Queue additional requests while processing
-                addModels: {
-                    actions: assign({
-                        _pendingModelAdditions: ({ context, event }) => {
-                            const existing = context._pendingModelAdditions || [];
-                            return [
-                                ...existing,
-                                {
-                                    models: event.models,
-                                    timestamp: Date.now(),
-                                },
-                            ];
-                        },
-                    }),
-                },
-            },
-            always: [
-                {
-                    // If there are pending additions after processing, process next one
-                    guard: ({ context }) => {
-                        const pending = context._pendingModelAdditions || [];
-                        return pending.length > 0;
-                    },
-                    target: 'addingModels',
-                },
-                {
-                    // No more pending, return to idle
-                    target: 'idle',
-                },
-            ],
-        },
-        validating: {
-            on: {
-                validationSuccess: {
-                    target: 'idle',
-                },
-                validationError: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'validateSchema',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        error: {},
-    },
-});
-
-export { schemaMachine };
-//# sourceMappingURL=schemaMachine.js.map