@seedprotocol/sdk 0.7.5 → 0.7.6-next.957.g6bb7768

package/dist/dist/Item-B1MH0tXx.d.ts.map

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

package/dist/dist/ModelProperty-Dw6dHdu_.d.ts

@@ -0,0 +1,315 @@
+export class ModelProperty {
+    static create(property: any, options: any): any;
+    /** Whether an idIndex entry still points at a cached instance with that id. */
+    static isIndexEntryCurrent(propertyFileId: any, entry: any): boolean;
+    /** Add a newly cached instance to idIndex, and keep its entry current when its id changes. */
+    static indexCachedInstance(cacheKey: any, instance: any): void;
+    /**
+     * Turns the caller's hold from the create call just made into model ownership: the instance stays
+     * cached and running for its model, and app holders' unload calls don't stop it.
+     * @internal Used by the model's property loading.
+     */
+    static adoptForModel(instance: any): void;
+    /**
+     * Get ModelProperty instance by propertyFileId from static cache
+     */
+    static getById(propertyFileId: any): any;
+    /**
+     * Create or get ModelProperty instance by propertyFileId
+     * Queries the database to find the property if not cached
+     */
+    static createById(propertyFileId: any, options: any): Promise<any>;
+    /**
+     * Give cached instances of these properties the values their rows now have (e.g. after a schema
+     * update reloaded them: renamed, dataType or storage changed). Nothing else updates them: createById
+     * and the Model's property refresh return a cached instance as is. A renamed instance's
+     * "modelName:oldName" cache entry is re-keyed so creating the property by its new name finds it.
+     * Instances with unsaved edits are left alone, as addModelsToDb leaves edited rows alone.
+     */
+    static refreshFromDb(propertyFileIds: any): Promise<void>;
+    /**
+     * Find ModelProperty instance by propertyFileId
+     * Waits for the property to be fully loaded (idle state) by default
+     * @param options - Find options including propertyFileId and wait configuration
+     * @returns ModelProperty instance if found, undefined otherwise
+     */
+    static find({ propertyFileId, waitForReady, readyTimeout, }: {
+        propertyFileId: any;
+        waitForReady?: boolean | undefined;
+        readyTimeout?: number | undefined;
+    }): Promise<any>;
+    /**
+     * Get all ModelProperty instances for a model.
+     * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
+     */
+    static all(modelFileId: any, options: any): Promise<any[]>;
+    /**
+     * Track a pending write for a property
+     */
+    static trackPendingWrite(propertyFileId: any, modelId: any): void;
+    /**
+     * A property write succeeded: add the property to its model's property ids, then drop the pending
+     * write. In that order, `Model.properties` (property ids + pending writes) never misses it; in Node,
+     * where the Model has no reactive liveQuery, nothing else would add it.
+     */
+    static completePendingWrite(propertyFileId: any, modelId: any): Promise<void>;
+    /**
+     * Clear or update pending write status
+     */
+    static clearPendingWrite(propertyFileId: any, status?: string): void;
+    /**
+     * Get all pending property IDs for a model
+     */
+    static getPendingPropertyIds(modelId: any): any[];
+    /**
+     * Get modelId for a property that has a pending write (row may not be in DB yet).
+     * Used to resolve modelName when validating a just-created property rename.
+     */
+    static getPendingModelId(propertyFileId: any): any;
+    /**
+     * Force-evict cached ModelProperty instances for the given models, ignoring refCounts, and stop
+     * their services. Used by Schema.destroy() so a re-imported schema gets fresh instances instead of
+     * ones holding a deleted row's _dbId.
+     */
+    static evictForModels(modelNames: any, schemaName: any): void;
+    constructor(property: any);
+    /** currentEvictionEpoch() at construction: lookups started for this instance don't outlive an eviction. */
+    _evictionEpoch: number;
+    _service: import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {
+        src: "writeProcessMachine";
+        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>;
+        id: string | undefined;
+    } | {
+        src: "saveToSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "compareAndMarkDraft";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateProperty";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }, import("xstate").MetaObject>>;
+    /**
+     * Send from fire-and-forget async work (DB lookups started in the constructor), which can finish
+     * after the instance was unloaded or evicted with its schema.
+     */
+    _sendIfRunning(event: any): void;
+    /**
+     * Initialize original values and schema name for tracking changes
+     * This is called asynchronously after construction
+     * If the property was loaded from the database and differs from the schema file,
+     * it will be marked as edited.
+     */
+    _initializeOriginalValues(property: any): void;
+    /**
+     * Load isEdited flag from database if property exists in DB
+     * @param property - The property data
+     * @param fallbackIsEdited - Fallback value if property doesn't exist in DB
+     * @returns The isEdited flag from database or fallback value
+     */
+    _loadIsEditedFromDb(property: any, fallbackIsEdited: any): Promise<any>;
+    /**
+     * Resolve refModelId from refModelName by querying the database
+     * @param refModelName - The name of the referenced model
+     * @returns The database ID of the referenced model, or undefined if not found
+     */
+    _resolveRefModelId(refModelName: any, property: any): Promise<any>;
+    /** Which model this property belongs to: its models row id and/or schema. */
+    _ownerModelScope(property: any): {
+        modelId: number | undefined;
+        schemaName: any;
+    };
+    /**
+     * Get schema file values for this property to use as "original" values
+     * This allows comparison with database values to detect edits
+     */
+    _getSchemaFileValues(property: any): Promise<{
+        name: any;
+        modelName: any;
+        dataType: any;
+        storageType: any;
+        localStorageDir: any;
+        filenameSuffix: any;
+    } | undefined>;
+    /**
+     * Set the schema name for this property by looking it up from the model
+     * Tries database first (more reliable), then falls back to schema files
+     */
+    _setSchemaName(property: any): Promise<void>;
+    /**
+     * Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished).
+     * Uses context.id (schemaFileId) and context.modelId to query properties → model_schemas → schemas.
+     */
+    _resolveSchemaNameForDestroy(db: any, context: any): Promise<any>;
+    /**
+     * Manually set the schema name for this property
+     * Useful when you know the schema name from context (e.g., when working with Schema instances)
+     */
+    setSchemaName(schemaName: any): void;
+    getService(): import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {
+        src: "writeProcessMachine";
+        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>;
+        id: string | undefined;
+    } | {
+        src: "saveToSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "compareAndMarkDraft";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateProperty";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }, import("xstate").MetaObject>>;
+    _getSnapshot(): import("xstate").MachineSnapshot<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {}, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>;
+    _getSnapshotContext(): {};
+    get path(): string | undefined;
+    get status(): {};
+    get isEdited(): any;
+    get validationErrors(): any;
+    get isValid(): boolean;
+    /**
+     * Validate the property
+     * @returns Validation result
+     */
+    validate(): Promise<any>;
+    save(): void;
+    /**
+     * Reload property from database
+     * This refreshes the actor context with the latest data from the database
+     * Note: ModelProperty doesn't have a dedicated load actor, so this will
+     * re-initialize from the current property data
+     */
+    reload(): Promise<void>;
+    /**
+     * Releases this caller's hold. The instance is shared: it keeps running while other callers hold
+     * it, or while its model owns it (a model's properties are stopped when the model is evicted).
+     * An instance nobody else holds is stopped and leaves the cache.
+     */
+    unload(): void;
+    /**
+     * Destroy the model property: remove from caches, delete from database, update Schema context, stop service.
+     */
+    destroy(): Promise<void>;
+}
+export namespace ModelProperty {
+    let instanceCache: Map<any, any>;
+    let idIndex: Map<any, any>;
+    let pendingWrites: Map<any, any>;
+}
+//# sourceMappingURL=ModelProperty-Dw6dHdu_.d.ts.map

package/dist/dist/ModelProperty-Dw6dHdu_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelProperty-Dw6dHdu_.d.ts","sourceRoot":"","sources":["../ModelProperty-Dw6dHdu_.js"],"names":[],"mappings":"AA+1BA;IAwZI,gDA+RC;IACD,+EAA+E;IAC/E,qEASC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAwEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAppCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA6EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IAynBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}