@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/src/ItemProperty/service/propertyMachine.d.ts

@@ -1,97 +1,48 @@
 import { PropertyMachineContext } from '@/types';
 export declare const propertyMachine: import("xstate").StateMachine<PropertyMachineContext, import("xstate").AnyEventObject, {
     [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>> | undefined;
-}, import("xstate").Values<{
-    saveRelation: {
-        src: "saveRelation";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    saveImage: {
-        src: "saveImage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    saveItemStorage: {
-        src: "saveItemStorage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    waitForDb: {
-        src: "waitForDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    hydrateFromDb: {
-        src: "hydrateFromDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    initialize: {
-        src: "initialize";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    resolveRelatedValue: {
-        src: "resolveRelatedValue";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    resolveRemoteStorage: {
-        src: "resolveRemoteStorage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    analyzeInput: {
-        src: "analyzeInput";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-}>, never, never, never, {}, string, PropertyMachineContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, import("xstate").MachineConfig<PropertyMachineContext, import("xstate").AnyEventObject, import("xstate").Values<{
-    saveRelation: {
-        src: "saveRelation";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    saveImage: {
-        src: "saveImage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    saveItemStorage: {
-        src: "saveItemStorage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    waitForDb: {
-        src: "waitForDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    hydrateFromDb: {
-        src: "hydrateFromDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    initialize: {
-        src: "initialize";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    resolveRelatedValue: {
-        src: "resolveRelatedValue";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    resolveRemoteStorage: {
-        src: "resolveRemoteStorage";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-    analyzeInput: {
-        src: "analyzeInput";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
-}>, never, never, never, string, PropertyMachineContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject>>;
+}, {
+    src: "saveRelation";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "saveImage";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "saveItemStorage";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "waitForDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "loadOrCreateProperty";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "hydrateFromDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "initialize";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "resolveRelatedValue";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "resolveRemoteStorage";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("xstate").EventObject>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "analyzeInput";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext, import("@/types").SaveValueToDbEvent>, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, never, never, {}, string, PropertyMachineContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id?: string | undefined | undefined;
+    states?: {} | undefined;
+}>;
 //# sourceMappingURL=propertyMachine.d.ts.map

package/dist/src/ItemProperty/service/propertyMachine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"propertyMachine.d.ts","sourceRoot":"","sources":["../../../../src/ItemProperty/service/propertyMachine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAehD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0JAyL1B,CAAA"}
+{"version":3,"file":"propertyMachine.d.ts","sourceRoot":"","sources":["../../../../src/ItemProperty/service/propertyMachine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAgBhD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2N1B,CAAA"}

package/dist/src/Model/Model.d.ts

@@ -0,0 +1,199 @@
+import { ActorRefFrom } from 'xstate';
+import { modelMachine, ModelMachineContext } from './service/modelMachine';
+import { Item } from '@/Item/Item';
+import { ItemData } from '@/types/item';
+type ModelService = ActorRefFrom<typeof modelMachine>;
+export declare class Model {
+    protected static instanceCacheById: Map<string, // modelFileId
+    {
+        instance: Model;
+        refCount: number;
+    }>;
+    protected static instanceCacheByName: Map<string, // "schemaName:modelName"
+    string>;
+    protected static instanceCache: Map<string, {
+        instance: Model;
+        refCount: number;
+    }>;
+    private static pendingWrites;
+    protected static savingModels: Set<string>;
+    private static cachedClientInitialized;
+    private static clientCheckTime;
+    private static readonly CLIENT_CHECK_CACHE_MS;
+    static trackPendingWrite(modelFileId: string, schemaId: number): void;
+    static getPendingModelIds(schemaId: number): string[];
+    protected readonly _service: ModelService;
+    modelName?: string;
+    schemaName?: string;
+    properties?: any[];
+    constructor(modelName: string, schemaName: string, id?: string, // schemaFileId (string) - public ID
+    initialContext?: Pick<ModelMachineContext, '_pendingPropertyDefinitions'>);
+    /**
+     * Find a unique model name by checking for duplicates (case-insensitive) in the cache
+     * If duplicates are found, appends an incrementing number to make it unique
+     *
+     * @param modelName - The desired model name
+     * @param schemaName - The schema name
+     * @param skipAllChecks - If true, skip all duplicate checks and return original name (used when creating schema models to preserve original names)
+     * @returns A unique model name
+     */
+    static findUniqueModelName(modelName: string, schemaName: string, skipAllChecks?: boolean): string;
+    /**
+     * Create a new Model instance or return existing cached instance
+     *
+     * @param modelName - The name of the model
+     * @param schemaNameOrSchema - The schema name (string) or Schema instance
+     * @param options - Optional configuration (can be omitted to create model with empty properties):
+     *   - modelFileId: Pre-existing model file ID
+     *   - properties: Model properties definition (defaults to empty object if not provided)
+     *   - registerWithSchema: Whether to automatically register this model with its schema (default: true if schema instance provided)
+     *
+     * @example
+     * // Create model with empty properties
+     * const model = Model.create('MyModel', schema)
+     *
+     * @example
+     * // Create model with properties
+     * const model = Model.create('MyModel', schema, {
+     *   properties: { title: { dataType: 'String' } }
+     * })
+     */
+    static create(modelName: string, schemaNameOrSchema: string | any, // Schema type - using any to avoid circular dependency
+    options?: {
+        id?: string;
+        modelFileId?: string;
+        properties?: {
+            [propertyName: string]: any;
+        };
+        registerWithSchema?: boolean;
+    }): Model;
+    /**
+     * Get Model instance by modelFileId (O(1) lookup)
+     */
+    static getById(modelFileId: string): Model | undefined;
+    /**
+     * Get Model instance by name (O(1) lookup via name→ID mapping)
+     *
+     * @param modelName - The name of the model
+     * @param schemaName - The schema name (optional, will query DB if not provided)
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static getByName(modelName: string, schemaName?: string): Model | undefined;
+    /**
+     * Get Model instance by name, querying database if not in cache
+     * This is an async version that can query the database when schemaName is not provided
+     *
+     * @param modelName - The name of the model
+     * @param schemaName - Optional schema name (will query DB if not provided)
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static getByNameAsync(modelName: string, schemaName?: string): Promise<Model | undefined>;
+    /**
+     * Create or get Model instance by modelFileId
+     * Checks cache first, then database if not found
+     *
+     * @param modelFileId - The model file ID to look up
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static createById(modelFileId: string): Promise<Model | undefined>;
+    /**
+     * Get all Model instances for a schema by schemaFileId or schemaName
+     * Queries database for all models with the given schemaId/schemaName and returns Model instances
+     *
+     * @param schemaIdentifier - The schema file ID or schema name to get models for
+     * @returns Array of Model instances for the schema
+     */
+    static createBySchemaId(schemaIdentifier: string): Promise<Model[]>;
+    /**
+     * Get all Model instances currently in cache
+     *
+     * @returns Array of all cached Model instances
+     */
+    static getAll(): Model[];
+    /**
+     * Get all Model instances for a specific schema from cache
+     * For database-backed lookup, use createBySchemaId() instead
+     *
+     * @param schemaName - The schema name to filter by
+     * @returns Array of Model instances for the schema
+     */
+    static getAllBySchema(schemaName: string): Model[];
+    /**
+     * Update name index when model name changes
+     */
+    static updateNameIndex(oldName: string, newName: string, schemaName: string, modelFileId: string): void;
+    getService(): ModelService;
+    private _getSnapshot;
+    private _getSnapshotContext;
+    /**
+     * Check for conflicts between actor context and database
+     * @returns ConflictResult indicating if a conflict exists
+     */
+    private _checkForConflicts;
+    /**
+     * Saves model name changes to the database immediately (draft save)
+     * This is called when modelName is changed to persist the change immediately
+     * @param oldName - The old model name (if name changed)
+     * @param newName - The new model name
+     */
+    private _saveDraftToDb;
+    get status(): "idle" | "error" | "validating" | "loading" | "creatingProperties";
+    get validationErrors(): import("../Schema").ValidationError[];
+    get isValid(): boolean;
+    get isEdited(): boolean;
+    get id(): string | undefined;
+    get name(): string;
+    /**
+     * Validate the model
+     * @returns Validation result
+     */
+    validate(): Promise<{
+        isValid: boolean;
+        errors: any[];
+    }>;
+    /**
+     * Create a new item instance from this model
+     * Automatically injects the model name, so you don't need to pass it explicitly.
+     *
+     * @example
+     * const Post = Model.create('Post', schema)
+     * const post = await Post.create({ title: 'My Post', content: '...' })
+     *
+     * @param values - Item property values (modelName is automatically injected)
+     * @returns The created item instance
+     */
+    create(values: Partial<ItemData> & Record<string, any>): Promise<Item<any>>;
+    /**
+     * Reload model from database
+     * This refreshes the actor context with the latest data from the database
+     */
+    reload(): Promise<void>;
+    /**
+     * Unload the model instance and clean up resources
+     */
+    unload(): void;
+    /**
+     * Destroy the model instance completely
+     * - Removes instance from all caches (regardless of refCount)
+     * - Deletes model records from database (models, properties, model_schemas tables)
+     * - Removes model from Schema's models property and instance caches
+     * - Cleans up registered ModelProperty instances
+     * - Stops the model service
+     */
+    destroy(): Promise<void>;
+    /**
+     * Set up liveQuery subscription to watch for property changes in the database
+     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
+     */
+    private _setupLiveQuerySubscription;
+    /**
+     * Refresh property IDs from database (useful in Node.js where liveQuery isn't available)
+     */
+    private _refreshPropertiesFromDb;
+    /**
+     * Public method to refresh properties from database
+     */
+    refreshProperties(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=Model.d.ts.map

package/dist/src/Model/Model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../../src/Model/Model.ts"],"names":[],"mappings":"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"}

package/dist/src/Model/index.d.ts

@@ -0,0 +1,26 @@
+export { Model } from './Model';
+export type { ModelMachineContext } from './service/modelMachine';
+export declare const TModelValues: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>;
+export declare const TModelSchema: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    _dbId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    dataType: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Text>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Number>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.List>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Relation>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Image>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Json>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.File>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Boolean>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Date>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Html>]>;
+    ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    modelId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    modelName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    refModelId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    refModelName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    refValueType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Text>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Number>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.List>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Relation>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Image>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Json>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.File>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Boolean>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Date>, import("@sinclair/typebox").TLiteral<import("../helpers/property/index").ModelPropertyDataTypes.Html>]>>;
+    storageType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"ItemStorage">, import("@sinclair/typebox").TLiteral<"PropertyStorage">]>>;
+    localStorageDir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    filenameSuffix: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    validation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        pattern: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        minLength: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxLength: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        enum: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TAny>>;
+        custom: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Model/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAMjE,eAAO,MAAM,YAAY,4GAAyC,CAAA;AAClE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;GAAwC,CAAA"}

package/dist/src/Model/service/actors/createModelProperties.d.ts

@@ -0,0 +1,9 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelMachineContext } from '../modelMachine';
+export declare const createModelProperties: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelMachineContext> & {
+    propertyDefinitions: {
+        [name: string]: any;
+    };
+}, EventObject>;
+//# sourceMappingURL=createModelProperties.d.ts.map

package/dist/src/Model/service/actors/createModelProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createModelProperties.d.ts","sourceRoot":"","sources":["../../../../../src/Model/service/actors/createModelProperties.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAKrD,eAAO,MAAM,qBAAqB;yBAEgC;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;eA4GvF,CAAA"}

package/dist/src/Model/service/actors/loadOrCreateModel.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelMachineContext } from '../modelMachine';
+export declare const loadOrCreateModel: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelMachineContext>, EventObject>;
+//# sourceMappingURL=loadOrCreateModel.d.ts.map

package/dist/src/Model/service/actors/loadOrCreateModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadOrCreateModel.d.ts","sourceRoot":"","sources":["../../../../../src/Model/service/actors/loadOrCreateModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAgDrD,eAAO,MAAM,iBAAiB,uGA+X5B,CAAA"}

package/dist/src/Model/service/actors/validateModel.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelMachineContext } from '../modelMachine';
+export declare const validateModel: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelMachineContext>, EventObject>;
+//# sourceMappingURL=validateModel.d.ts.map

package/dist/src/Model/service/actors/validateModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateModel.d.ts","sourceRoot":"","sources":["../../../../../src/Model/service/actors/validateModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAarD,eAAO,MAAM,aAAa,uGAgIxB,CAAA"}

package/dist/src/Model/service/modelMachine.d.ts

@@ -0,0 +1,206 @@
+import { ActorRefFrom } from 'xstate';
+import { ValidationError } from '@/Schema/validation';
+import { writeProcessMachine } from '@/services/write/writeProcessMachine';
+export type ModelMachineContext = {
+    id?: string;
+    _dbId?: number;
+    modelName: string;
+    schemaName: string;
+    _isEdited?: boolean;
+    _editedProperties?: Set<string>;
+    _validationErrors?: ValidationError[];
+    _originalValues?: {
+        properties?: {
+            [propertyName: string]: any;
+        };
+    };
+    writeProcess?: ActorRefFrom<typeof writeProcessMachine> | null;
+    _liveQueryPropertyIds?: string[];
+    _pendingPropertyDefinitions?: {
+        [propertyName: string]: any;
+    };
+    _loadedAt?: number;
+    _dbVersion?: number;
+    _dbUpdatedAt?: number;
+};
+export declare const modelMachine: import("xstate").StateMachine<ModelMachineContext, {
+    [key: string]: any;
+    type: "updateContext";
+} | {
+    type: "loadOrCreateModel";
+} | {
+    type: "loadOrCreateModelSuccess";
+    model: Omit<ModelMachineContext, "modelName" | "schemaName" | "_isEdited" | "_editedProperties" | "_validationErrors" | "_loadedAt" | "_dbVersion" | "_dbUpdatedAt"> & Partial<Pick<ModelMachineContext, "_loadedAt" | "_dbVersion" | "_dbUpdatedAt">>;
+} | {
+    type: "loadOrCreateModelError";
+    error: Error;
+} | {
+    type: "initializeOriginalValues";
+    originalValues: Partial<ModelMachineContext>;
+    isEdited?: boolean;
+} | {
+    type: "markAsDraft";
+    propertyKey: string;
+} | {
+    type: "clearDraft";
+} | {
+    type: "validateModel";
+} | {
+    type: "validationSuccess";
+    errors: ValidationError[];
+} | {
+    type: "validationError";
+    errors: ValidationError[];
+} | {
+    type: "reloadFromDb";
+} | {
+    type: "requestWrite";
+    data: any;
+} | {
+    type: "writeSuccess";
+    output: any;
+} | {
+    type: "createModelPropertiesSuccess";
+} | {
+    type: "createModelPropertiesError";
+    error: Error;
+} | {
+    type: "refreshProperties";
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<import("@/services/write/writeProcessMachine").WriteProcessContext, {
+        type: "startWrite";
+        data: any;
+    } | {
+        type: "validate";
+    } | {
+        type: "write";
+    } | {
+        type: "writeSuccess";
+        output?: any;
+    } | {
+        type: "writeError";
+        error: Error;
+    } | {
+        type: "retry";
+    } | {
+        type: "revert";
+    } | {
+        type: "reset";
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeToDatabase";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext> & {
+        propertyDefinitions: {
+            [name: string]: any;
+        };
+    }, import("xstate").EventObject>> | undefined;
+}, {
+    src: "writeProcessMachine";
+    logic: import("xstate").StateMachine<import("@/services/write/writeProcessMachine").WriteProcessContext, {
+        type: "startWrite";
+        data: any;
+    } | {
+        type: "validate";
+    } | {
+        type: "write";
+    } | {
+        type: "writeSuccess";
+        output?: any;
+    } | {
+        type: "writeError";
+        error: Error;
+    } | {
+        type: "retry";
+    } | {
+        type: "revert";
+    } | {
+        type: "reset";
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeToDatabase";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>;
+    id: string | undefined;
+} | {
+    src: "loadOrCreateModel";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateModel";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createModelProperties";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext> & {
+        propertyDefinitions: {
+            [name: string]: any;
+        };
+    }, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "assignValidationErrors";
+    params: import("xstate").NonReducibleUnknown;
+}, {
+    type: "hasValidationErrors";
+    params: unknown;
+} | {
+    type: "isModelValid";
+    params: unknown;
+}, never, "idle" | "error" | "validating" | "loading" | "creatingProperties", string, Pick<ModelMachineContext, "id" | "modelName" | "schemaName" | "_pendingPropertyDefinitions">, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "model";
+    states: {
+        readonly loading: {};
+        readonly idle: {};
+        readonly validating: {};
+        readonly creatingProperties: {};
+        readonly error: {};
+    };
+}>;
+//# sourceMappingURL=modelMachine.d.ts.map

package/dist/src/Model/service/modelMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelMachine.d.ts","sourceRoot":"","sources":["../../../../src/Model/service/modelMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,YAAY,EAAE,MAAM,QAAQ,CAAA;AAIpD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAA;AAK1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAA;IAErC,eAAe,CAAC,EAAE;QAChB,UAAU,CAAC,EAAE;YAAE,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAA;KAC7C,CAAA;IACD,YAAY,CAAC,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAC9D,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAA;IAChC,2BAA2B,CAAC,EAAE;QAAE,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IAE7D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,YAAY;;UAKT,eAAe;;UACf,mBAAmB;;UACnB,0BAA0B;WAAS,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,mBAAmB,GAAG,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC,CAAC;;UAClR,wBAAwB;WAAS,KAAK;;UACtC,0BAA0B;oBAAkB,OAAO,CAAC,mBAAmB,CAAC;eAAa,OAAO;;UAC5F,aAAa;iBAAe,MAAM;;UAClC,YAAY;;UACZ,eAAe;;UACf,mBAAmB;YAAU,eAAe,EAAE;;UAC9C,iBAAiB;YAAU,eAAe,EAAE;;UAC5C,cAAc;;UACd,cAAc;UAAQ,GAAG;;UACzB,cAAc;YAAU,GAAG;;UAC3B,8BAA8B;;UAC9B,4BAA4B;WAAS,KAAK;;UAC1C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsXjC,CAAA"}