@tanstack/db-sqlite-persistence-core 0.4.4 → 0.4.5

package/dist/esm/remote-subset-wire.d.ts

@@ -55,5 +55,7 @@ export declare class RemoteSubsetWireValueError extends TypeError {
  * Validation happens before callers choose a local-leader or transported path.
  */
 export declare function toTransportedLoadSubsetOptions(options: LoadSubsetOptions): TransportedLoadSubsetOptions;
+/** Checks wire admission without constructing a detached request snapshot. */
+export declare function validateRemoteSubsetOptions(options: LoadSubsetOptions): void;
 /** Adds live lifecycle references only to an already validated local request. */
 export declare function toProcessLocalLoadSubsetOptions(options: LoadSubsetOptions, transported?: TransportedLoadSubsetOptions): TransportedLoadSubsetOptions & Pick<LoadSubsetOptions, `signal` | `subscription`>;

package/dist/esm/remote-subset-wire.js

@@ -22,6 +22,12 @@ const typedArrayConstructors = [
 const NativeDate = Date;
 const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function toTransportedLoadSubsetOptions(options) {
+  return visitLoadSubsetOptions(options, false);
+}
+function validateRemoteSubsetOptions(options) {
+  visitLoadSubsetOptions(options, true);
+}
+function visitLoadSubsetOptions(options, validateOnly) {
   assertPlainContainer(options, `options`);
   assertAllowedProperties(options, `options`, [
     `where`,
@@ -33,6 +39,7 @@ function toTransportedLoadSubsetOptions(options) {
     `subscription`
   ]);
   const state = {
+    validateOnly,
     expressions: /* @__PURE__ */ new WeakMap(),
     expressionArrays: /* @__PURE__ */ new WeakMap(),
     stringArrays: /* @__PURE__ */ new WeakMap(),
@@ -42,26 +49,31 @@ function toTransportedLoadSubsetOptions(options) {
     cursors: /* @__PURE__ */ new WeakMap(),
     wireValues: /* @__PURE__ */ new WeakMap()
   };
-  const projected = {};
+  const projected = validateOnly ? options : {};
   const where = readDataProperty(options, `where`, `options.where`);
   const orderBy = readDataProperty(options, `orderBy`, `options.orderBy`);
   const limit = readDataProperty(options, `limit`, `options.limit`);
   const cursor = readDataProperty(options, `cursor`, `options.cursor`);
   const offset = readDataProperty(options, `offset`, `options.offset`);
   if (where.present && where.value !== void 0) {
-    projected.where = projectExpression(where.value, `options.where`, state);
+    const result = projectExpression(where.value, `options.where`, state);
+    if (!state.validateOnly) projected.where = result;
   }
   if (orderBy.present && orderBy.value !== void 0) {
-    projected.orderBy = projectOrderBy(orderBy.value, `options.orderBy`, state);
+    const result = projectOrderBy(orderBy.value, `options.orderBy`, state);
+    if (!state.validateOnly) projected.orderBy = result;
   }
   if (limit.present && limit.value !== void 0) {
-    projected.limit = projectNumber(limit.value, `options.limit`);
+    const result = projectNumber(limit.value, `options.limit`);
+    if (!state.validateOnly) projected.limit = result;
   }
   if (cursor.present && cursor.value !== void 0) {
-    projected.cursor = projectCursor(cursor.value, `options.cursor`, state);
+    const result = projectCursor(cursor.value, `options.cursor`, state);
+    if (!state.validateOnly) projected.cursor = result;
   }
   if (offset.present && offset.value !== void 0) {
-    projected.offset = projectNumber(offset.value, `options.offset`);
+    const result = projectNumber(offset.value, `options.offset`);
+    if (!state.validateOnly) projected.offset = result;
   }
   return projected;
 }
@@ -95,65 +107,58 @@ function projectExpression(value, path, state) {
     case `ref`: {
       assertExpressionPrototype(object, path, IR.PropRef.prototype);
       assertAllowedProperties(object, path, [`type`, `path`, `sourceAlias`]);
-      const projected = {
-        type: `ref`,
-        path: []
-      };
+      const projected = state.validateOnly ? object : { type: `ref`, path: [] };
       state.expressions.set(object, projected);
       const sourcePath = readRequiredDataProperty(
         object,
         `path`,
         `${path}.path`
       );
-      projected.path = projectStringArray(sourcePath, `${path}.path`, state);
+      const result = projectStringArray(sourcePath, `${path}.path`, state);
+      if (!state.validateOnly) projected.path = result;
       const sourceAlias = readDataProperty(
         object,
         `sourceAlias`,
         `${path}.sourceAlias`
       );
       if (sourceAlias.present) {
-        if (typeof sourceAlias.value !== `string` || projected.path[0] !== sourceAlias.value) {
+        if (typeof sourceAlias.value !== `string` || result[0] !== sourceAlias.value) {
           throw new RemoteSubsetWireValueError(
             `${path}.sourceAlias`,
             `source alias must match the first path segment`
           );
         }
-        projected.sourceAlias = sourceAlias.value;
+        if (!state.validateOnly) projected.sourceAlias = sourceAlias.value;
       }
       return projected;
     }
     case `val`: {
       assertExpressionPrototype(object, path, IR.Value.prototype);
       assertAllowedProperties(object, path, [`type`, `value`]);
-      const projected = {
-        type: `val`,
-        value: void 0
-      };
+      const projected = state.validateOnly ? object : { type: `val`, value: void 0 };
       state.expressions.set(object, projected);
       const sourceValue = readRequiredDataProperty(
         object,
         `value`,
         `${path}.value`
       );
-      projected.value = projectWireValue(sourceValue, `${path}.value`, state);
+      const result = projectWireValue(sourceValue, `${path}.value`, state);
+      if (!state.validateOnly) projected.value = result;
       return projected;
     }
     case `func`: {
       assertExpressionPrototype(object, path, IR.Func.prototype);
       assertAllowedProperties(object, path, [`type`, `name`, `args`]);
-      const projected = {
-        type: `func`,
-        name: ``,
-        args: []
-      };
+      const projected = state.validateOnly ? object : { type: `func`, name: ``, args: [] };
       state.expressions.set(object, projected);
       const name = readRequiredDataProperty(object, `name`, `${path}.name`);
       if (typeof name !== `string`) {
         throw new RemoteSubsetWireValueError(`${path}.name`, describe(name));
       }
-      projected.name = name;
+      if (!state.validateOnly) projected.name = name;
       const args = readRequiredDataProperty(object, `args`, `${path}.args`);
-      projected.args = projectExpressionArray(args, `${path}.args`, state);
+      const result = projectExpressionArray(args, `${path}.args`, state);
+      if (!state.validateOnly) projected.args = result;
       return projected;
     }
     default:
@@ -165,7 +170,7 @@ function projectExpressionArray(value, path, state) {
   const existing = state.expressionArrays.get(array);
   if (existing) return existing;
   assertArrayShape(array, path);
-  const projected = new Array(array.length);
+  const projected = state.validateOnly ? array : new Array(array.length);
   state.expressionArrays.set(array, projected);
   for (let index = 0; index < array.length; index++) {
     if (!(index in array)) {
@@ -174,11 +179,8 @@ function projectExpressionArray(value, path, state) {
         `missing expression`
       );
     }
-    projected[index] = projectExpression(
-      array[index],
-      `${path}[${index}]`,
-      state
-    );
+    const result = projectExpression(array[index], `${path}[${index}]`, state);
+    if (!state.validateOnly) projected[index] = result;
   }
   return projected;
 }
@@ -187,14 +189,14 @@ function projectStringArray(value, path, state) {
   const existing = state.stringArrays.get(array);
   if (existing) return existing;
   assertArrayShape(array, path);
-  const projected = new Array(array.length);
+  const projected = state.validateOnly ? array : new Array(array.length);
   state.stringArrays.set(array, projected);
   for (let index = 0; index < array.length; index++) {
     const entry = array[index];
     if (!(index in array) || typeof entry !== `string`) {
       throw new RemoteSubsetWireValueError(`${path}[${index}]`, describe(entry));
     }
-    projected[index] = entry;
+    if (!state.validateOnly) projected[index] = entry;
   }
   return projected;
 }
@@ -203,27 +205,27 @@ function projectOrderBy(value, path, state) {
   const existing = state.orderByArrays.get(array);
   if (existing) return existing;
   assertArrayShape(array, path);
-  const projected = new Array(array.length);
+  const projected = state.validateOnly ? array : new Array(array.length);
   state.orderByArrays.set(array, projected);
   for (let index = 0; index < array.length; index++) {
     const clausePath = `${path}[${index}]`;
     const clause = requirePlainRecord(array[index], clausePath);
     const existingClause = state.orderByClauses.get(clause);
     if (existingClause) {
-      projected[index] = existingClause;
+      if (!state.validateOnly) projected[index] = existingClause;
       continue;
     }
     assertAllowedProperties(clause, clausePath, [
       `expression`,
       `compareOptions`
     ]);
-    const projectedClause = {
+    const projectedClause = state.validateOnly ? clause : {
       expression: void 0,
       compareOptions: void 0
     };
-    projected[index] = projectedClause;
+    if (!state.validateOnly) projected[index] = projectedClause;
     state.orderByClauses.set(clause, projectedClause);
-    projectedClause.expression = projectExpression(
+    const expression = projectExpression(
       readRequiredDataProperty(
         clause,
         `expression`,
@@ -232,7 +234,7 @@ function projectOrderBy(value, path, state) {
       `${clausePath}.expression`,
       state
     );
-    projectedClause.compareOptions = projectCompareOptions(
+    const compareOptions = projectCompareOptions(
       readRequiredDataProperty(
         clause,
         `compareOptions`,
@@ -241,6 +243,10 @@ function projectOrderBy(value, path, state) {
       `${clausePath}.compareOptions`,
       state
     );
+    if (!state.validateOnly) {
+      projectedClause.expression = expression;
+      projectedClause.compareOptions = compareOptions;
+    }
   }
   return projected;
 }
@@ -255,7 +261,7 @@ function projectCompareOptions(value, path, state) {
     `locale`,
     `localeOptions`
   ]);
-  const projected = {};
+  const projected = state.validateOnly ? source : {};
   const direction = readRequiredDataProperty(
     source,
     `direction`,
@@ -267,12 +273,12 @@ function projectCompareOptions(value, path, state) {
       describe(direction)
     );
   }
-  projected.direction = direction;
+  if (!state.validateOnly) projected.direction = direction;
   const nulls = readRequiredDataProperty(source, `nulls`, `${path}.nulls`);
   if (nulls !== `first` && nulls !== `last`) {
     throw new RemoteSubsetWireValueError(`${path}.nulls`, describe(nulls));
   }
-  projected.nulls = nulls;
+  if (!state.validateOnly) projected.nulls = nulls;
   const stringSort = readDataProperty(
     source,
     `stringSort`,
@@ -285,7 +291,7 @@ function projectCompareOptions(value, path, state) {
         describe(stringSort.value)
       );
     }
-    projected.stringSort = stringSort.value;
+    if (!state.validateOnly) projected.stringSort = stringSort.value;
   }
   if (projected.stringSort !== `lexical`) {
     const locale = readDataProperty(source, `locale`, `${path}.locale`);
@@ -296,7 +302,7 @@ function projectCompareOptions(value, path, state) {
           describe(locale.value)
         );
       }
-      projected.locale = locale.value;
+      if (!state.validateOnly) projected.locale = locale.value;
     }
     const localeOptions = readDataProperty(
       source,
@@ -304,11 +310,12 @@ function projectCompareOptions(value, path, state) {
       `${path}.localeOptions`
     );
     if (localeOptions.present && localeOptions.value !== void 0) {
-      projected.localeOptions = projectWireRecord(
+      const result2 = projectWireRecord(
         localeOptions.value,
         `${path}.localeOptions`,
         state
       );
+      if (!state.validateOnly) projected.localeOptions = result2;
     }
   }
   const result = projected;
@@ -324,21 +331,25 @@ function projectCursor(value, path, state) {
     `whereCurrent`,
     `lastKey`
   ]);
-  const projected = {
+  const projected = state.validateOnly ? source : {
     whereFrom: void 0,
     whereCurrent: void 0
   };
   state.cursors.set(source, projected);
-  projected.whereFrom = projectExpression(
+  const whereFrom = projectExpression(
     readRequiredDataProperty(source, `whereFrom`, `${path}.whereFrom`),
     `${path}.whereFrom`,
     state
   );
-  projected.whereCurrent = projectExpression(
+  const whereCurrent = projectExpression(
     readRequiredDataProperty(source, `whereCurrent`, `${path}.whereCurrent`),
     `${path}.whereCurrent`,
     state
   );
+  if (!state.validateOnly) {
+    projected.whereFrom = whereFrom;
+    projected.whereCurrent = whereCurrent;
+  }
   const lastKey = readDataProperty(source, `lastKey`, `${path}.lastKey`);
   if (lastKey.present && lastKey.value !== void 0) {
     if (typeof lastKey.value !== `string` && typeof lastKey.value !== `number`) {
@@ -347,7 +358,7 @@ function projectCursor(value, path, state) {
         describe(lastKey.value)
       );
     }
-    projected.lastKey = lastKey.value;
+    if (!state.validateOnly) projected.lastKey = lastKey.value;
   }
   return projected;
 }
@@ -366,14 +377,16 @@ function projectWireValue(value, path, state) {
   if (value instanceof NativeDate) {
     assertExactPrototype(value, NativeDate.prototype, path);
     assertNoOwnProperties(value, path);
-    const projected = new NativeDate(value.getTime());
+    const time = value.getTime();
+    const projected = state.validateOnly ? value : new NativeDate(time);
     state.wireValues.set(value, projected);
     return projected;
   }
   if (value instanceof RegExp) {
     assertExactPrototype(value, RegExp.prototype, path);
     assertRegExpShape(value, path);
-    const projected = new RegExp(value.source, value.flags);
+    const { source, flags } = value;
+    const projected = state.validateOnly ? value : new RegExp(source, flags);
     state.wireValues.set(value, projected);
     return projected;
   }
@@ -383,7 +396,12 @@ function projectWireValue(value, path, state) {
     assertFixedArrayBuffer(value, path);
     let projected;
     try {
-      projected = value.slice(0);
+      if (state.validateOnly) {
+        new Uint8Array(value, 0, 0);
+        projected = value;
+      } else {
+        projected = value.slice(0);
+      }
     } catch {
       throw new RemoteSubsetWireValueError(path, `detached ArrayBuffer`);
     }
@@ -407,7 +425,7 @@ function projectWireValue(value, path, state) {
     if (!(projectedBuffer instanceof ArrayBuffer)) {
       throw new RemoteSubsetWireValueError(path, `shared DataView buffer`);
     }
-    const projected = new DataView(projectedBuffer, byteOffset, byteLength);
+    const projected = state.validateOnly ? value : new DataView(projectedBuffer, byteOffset, byteLength);
     state.wireValues.set(value, projected);
     return projected;
   }
@@ -434,7 +452,7 @@ function projectWireValue(value, path, state) {
     }
     let projected;
     try {
-      projected = new typedArrayConstructor(projectedBuffer, byteOffset, length);
+      projected = state.validateOnly ? typedArray : new typedArrayConstructor(projectedBuffer, byteOffset, length);
     } catch {
       throw new RemoteSubsetWireValueError(path, `detached typed array`);
     }
@@ -451,15 +469,12 @@ function projectWireValue(value, path, state) {
 }
 function projectWireArray(value, path, state) {
   assertArrayShape(value, path);
-  const projected = new Array(value.length);
+  const projected = state.validateOnly ? value : new Array(value.length);
   state.wireValues.set(value, projected);
   for (let index = 0; index < value.length; index++) {
     if (index in value) {
-      projected[index] = projectWireValue(
-        value[index],
-        `${path}[${index}]`,
-        state
-      );
+      const result = projectWireValue(value[index], `${path}[${index}]`, state);
+      if (!state.validateOnly) projected[index] = result;
     }
   }
   return projected;
@@ -467,14 +482,21 @@ function projectWireArray(value, path, state) {
 function projectWireMap(value, path, state) {
   assertExactPrototype(value, Map.prototype, path);
   assertNoOwnProperties(value, path);
-  const projected = /* @__PURE__ */ new Map();
+  const projected = state.validateOnly ? value : /* @__PURE__ */ new Map();
   state.wireValues.set(value, projected);
   let index = 0;
   for (const [key, entry] of value) {
-    projected.set(
-      projectWireValue(key, `${path}.entries[${index}].key`, state),
-      projectWireValue(entry, `${path}.entries[${index}].value`, state)
+    const projectedKey = projectWireValue(
+      key,
+      `${path}.entries[${index}].key`,
+      state
     );
+    const projectedValue = projectWireValue(
+      entry,
+      `${path}.entries[${index}].value`,
+      state
+    );
+    if (!state.validateOnly) projected.set(projectedKey, projectedValue);
     index++;
   }
   return projected;
@@ -482,11 +504,12 @@ function projectWireMap(value, path, state) {
 function projectWireSet(value, path, state) {
   assertExactPrototype(value, Set.prototype, path);
   assertNoOwnProperties(value, path);
-  const projected = /* @__PURE__ */ new Set();
+  const projected = state.validateOnly ? value : /* @__PURE__ */ new Set();
   state.wireValues.set(value, projected);
   let index = 0;
   for (const entry of value) {
-    projected.add(projectWireValue(entry, `${path}.values[${index}]`, state));
+    const result = projectWireValue(entry, `${path}.values[${index}]`, state);
+    if (!state.validateOnly) projected.add(result);
     index++;
   }
   return projected;
@@ -495,7 +518,7 @@ function projectWireRecord(value, path, state) {
   const source = requirePlainRecord(value, path);
   const existing = state.wireValues.get(source);
   if (existing) return existing;
-  const projected = {};
+  const projected = state.validateOnly ? source : {};
   state.wireValues.set(source, projected);
   for (const key of ownKeys(source, path)) {
     const childPath = propertyPath(path, key);
@@ -506,12 +529,15 @@ function projectWireRecord(value, path, state) {
     if (!descriptor || !descriptor.enumerable || !(`value` in descriptor)) {
       throw new RemoteSubsetWireValueError(childPath, `non-data property`);
     }
-    Object.defineProperty(projected, key, {
-      value: projectWireValue(descriptor.value, childPath, state),
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
+    const result = projectWireValue(descriptor.value, childPath, state);
+    if (!state.validateOnly) {
+      Object.defineProperty(projected, key, {
+        value: result,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
   }
   return projected;
 }
@@ -676,6 +702,7 @@ function describe(value) {
 export {
   RemoteSubsetWireValueError,
   toProcessLocalLoadSubsetOptions,
-  toTransportedLoadSubsetOptions
+  toTransportedLoadSubsetOptions,
+  validateRemoteSubsetOptions
 };
 //# sourceMappingURL=remote-subset-wire.js.map