@converse/skeletor 3.1.3 → 3.1.5

package/package.json

@@ -9,6 +9,7 @@
   "browser": "dist/skeletor.js",
   "exports": {
     ".": {
+      "types": "./dist/skeletor.d.ts",
       "node": {
         "require": "./dist/skeletor.node.js",
         "import": "./dist/skeletor.node.mjs"
@@ -19,6 +20,7 @@
       }
     },
     "./node": {
+      "types": "./dist/skeletor.d.ts",
       "require": "./dist/skeletor.node.js",
       "import": "./dist/skeletor.node.mjs"
     }
@@ -36,7 +38,7 @@
   "contributors": [
     "JC Brand"
   ],
-  "version": "3.1.3",
+  "version": "3.1.5",
   "engines": {
     "node": ">=22.0.0"
   },

package/src/collection.ts

@@ -40,7 +40,7 @@ export class Collection<T extends Model = Model> extends EventEmitterObject {
   _storage?: PersistentStorage;
   _comparator?: Comparator<T>;
   _url: string = '';
-  initialized?: Promise<void>;
+  hydrated?: Promise<void>;
   models: T[];
   protected _byId: Record<string, T>;
   protected _model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
@@ -61,11 +61,11 @@ export class Collection<T extends Model = Model> extends EventEmitterObject {
     if (models) this.reset(models, Object.assign({ silent: true }, options));
 
     this[Symbol.iterator] = this.values;
-    // When autoSync is on, `initialized` is always a Promise so callers can
-    // uniformly `await collection.initialized`; it resolves immediately when
+    // When autoSync is on, `hydrated` is always a Promise so callers can
+    // uniformly `await collection.hydrated`; it resolves immediately when
     // there's no storage to hydrate from.
     if (this.autoSync) {
-      this.initialized = getStorage(this) ? this.#hydrate() : Promise.resolve();
+      this.hydrated = getStorage(this) ? this.#hydrate() : Promise.resolve();
     }
   }
 
@@ -104,7 +104,7 @@ export class Collection<T extends Model = Model> extends EventEmitterObject {
 
   /**
    * Override to return `true` to automatically load the collection from
-   * storage on construction. Await `initialized` to know when hydration
+   * storage on construction. Await `hydrated` to know when hydration
    * is complete.
    *
    * Note: collection `autoSync` is hydrate-only. Unlike `Model`, it does

package/src/declarations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@converse/localforage-getitems` ships its types as an ambient script that
+ * declares the *unscoped* module name (`localforage-getitems`), left over from
+ * the package it was forked from. TypeScript therefore resolves the scoped
+ * specifier to a `typings/index.d.ts` that isn't a module (TS2306), so declare
+ * the shape we use here instead.
+ */
+declare module '@converse/localforage-getitems' {
+  export function extendPrototype<T>(localforage: T): T;
+  export const extendPrototypeResult: boolean;
+}

package/src/drivers/nodeSQLiteStorage.ts

@@ -27,11 +27,6 @@ export class NodeSQLiteStorage implements StorageDriver {
     return Promise.resolve();
   }
 
-  debouncedSetItems?: {
-    (items: Record<string, any>): Promise<void>;
-    flush?: () => void;
-  };
-
   constructor(name: string, storageDir?: string, inMemory?: boolean) {
     if (inMemory) {
       this.db = new DatabaseSync(':memory:');
@@ -116,7 +111,7 @@ export class NodeSQLiteStorage implements StorageDriver {
     return Promise.resolve(rows.map((r) => r.key));
   }
 
-  setItems(items: Record<string, any>): Promise<void> {
+  setItems(items: Record<string, any>): Promise<Record<string, any>> {
     this.db.exec('BEGIN IMMEDIATE');
     try {
       for (const [key, value] of Object.entries(items)) {
@@ -137,7 +132,7 @@ export class NodeSQLiteStorage implements StorageDriver {
       }
       throw e;
     }
-    return Promise.resolve();
+    return Promise.resolve(items);
   }
 
   getItems(keys: string[]): Promise<Record<string, any>> {

package/src/drivers/types.ts

@@ -11,10 +11,16 @@ export interface StorageDriver {
   length(): Promise<number>;
   key(keyIndex: number): Promise<string | null>;
   keys(): Promise<string[]>;
-  setItems?(items: Record<string, any>): Promise<void>;
+  /**
+   * Write several items in one go. A successful write is signalled by the
+   * promise settling, not by what it resolves with: drivers may resolve with
+   * the written items (localForage does) or with nothing, and callers must
+   * treat both as success.
+   */
+  setItems?(items: Record<string, any>): Promise<Record<string, any> | void>;
   getItems?(keys: string[]): Promise<Record<string, any>>;
   debouncedSetItems?: {
-    (items: Record<string, any>): Promise<void>;
+    (items: Record<string, any>): Promise<Record<string, any> | void>;
     flush?: () => void;
   };
 }

package/src/model.ts

@@ -58,7 +58,7 @@ export class Model<T extends ModelAttributes = ModelAttributes> extends EventEmi
   cid: string;
   collection?: Collection;
   id: string | number;
-  initialized?: Promise<void>;
+  hydrated?: Promise<void>;
   validationError: string | number | null = null;
 
   /**
@@ -102,17 +102,17 @@ export class Model<T extends ModelAttributes = ModelAttributes> extends EventEmi
     // Reset changed after initial set
     this.changed = {};
 
-    // When autoSync is on, `initialized` is always a Promise so callers can
-    // uniformly `await model.initialized`. It only hydrates from storage when
+    // When autoSync is on, `hydrated` is always a Promise so callers can
+    // uniformly `await model.hydrated`. It only hydrates from storage when
     // there's something to load (storage configured and the model isn't new);
     // otherwise it's already ready and resolves immediately.
     if (this.autoSync) {
       if (getStorage(this) && !this.isNew()) {
         this.#state = 'hydrating';
-        this.initialized = this.#hydrate();
+        this.hydrated = this.#hydrate();
       } else {
         this.#state = 'ready';
-        this.initialized = Promise.resolve();
+        this.hydrated = Promise.resolve();
       }
     } else {
       this.#state = 'ready';
@@ -347,7 +347,7 @@ export class Model<T extends ModelAttributes = ModelAttributes> extends EventEmi
     // fromStorage lives in `val` (second arg), not `options` (third arg).
     if (this.autoSync && this.#state === 'hydrating' && !options.fromStorage) {
       throw new Error(
-        `Skeletor: set() called on an autoSync model before initialized resolved. Await model.initialized first.`,
+        `Skeletor: set() called on an autoSync model before hydration resolved. Await model.hydrated first.`,
       );
     }
 

package/src/storage.ts

@@ -8,7 +8,7 @@ import localForage from 'localforage';
 import mergebounce from 'mergebounce';
 import sessionStorageWrapper from './drivers/sessionStorage';
 import { extendPrototype as extendPrototypeWithSetItems } from 'localforage-setitems';
-import { extendPrototype as extendPrototypeWithGetItems } from '@converse/localforage-getitems/dist/localforage-getitems.es6';
+import { extendPrototype as extendPrototypeWithGetItems } from '@converse/localforage-getitems';
 import { guid } from './helpers';
 import type { Model } from './model';
 import type { Collection } from './collection';
@@ -231,31 +231,16 @@ class PersistentStorage {
         }
       }
 
-      if (resp) {
-        if (options && options.success) {
-          // When storing, we don't pass back the response (which is
-          // the set attributes returned from localforage because
-          // Skeletor sets them again on the model and due to the async
-          // nature of localforage it can cause stale attributes to be
-          // set on a model after it's been updated in the meantime.
-          const data = method === 'read' ? resp : null;
-          options.success(data, options);
-        }
-      } else if (method === 'read' && !caughtError) {
-        // A read that finds no record is a normal empty result (first run /
-        // empty storage), not an error. Resolve with `null` so the callback
-        // and promise forms of fetch() agree and a first-run read never
-        // rejects.
-        if (options && options.success) {
-          options.success(null, options);
-        }
-      } else {
-        // A genuine failure (storage threw, or a write produced no result):
-        // surface a real Error so consumers get a stack and `instanceof Error`
-        // holds.
-        if (options && options.error) {
-          options.error(caughtError ?? new Error('Record Not Found'));
-        }
+      if (caughtError) {
+        options?.error?.(caughtError);
+      } else if (options?.success) {
+        // When storing, we don't pass back the response (which is the set
+        // attributes returned from localforage) because Skeletor sets them
+        // again on the model and due to the async nature of localforage it can
+        // cause stale attributes to be set on a model after it's been updated
+        // in the meantime.
+        const data = method === 'read' ? (resp ?? null) : null;
+        options.success(data, options);
       }
     }
     localSync.__name__ = 'localSync';