ugly-app 0.1.821 → 0.1.823

package/src/server/sqlite/assertIndexed.ts

@@ -0,0 +1,58 @@
+/**
+ * Backend-agnostic index-coverage pre-flight. Throws when a query filters or
+ * sorts on a field with no declared index — surfacing missing indexes in
+ * dev/test instead of silently full-scanning (D1 has no GIN fallback; this also
+ * hardens Neon). Coverage mirrors PostgresIndexes: every field named in any
+ * declared index is covered (a composite credits all its fields). Enhancement
+ * over PG's warn-only checker: sort keys are checked too, and it THROWS.
+ */
+import type { IndexDef } from '../../shared/DB.js';
+import { collectJsonFields } from './SqliteFilter.js';
+
+const TOP_LEVEL_COLUMNS = new Set(['_id', 'created', 'updated', 'version']);
+
+export class UnindexedQueryError extends Error {
+  constructor(
+    public readonly collection: string,
+    public readonly field: string,
+  ) {
+    super(
+      `Collection "${collection}" filters/sorts on "${field}" which has no index. ` +
+        `Add to meta.indexes: { fields: { ${field}: 1 } } — or pass { allowScan: true } ` +
+        `for a deliberate full scan.`,
+    );
+    this.name = 'UnindexedQueryError';
+  }
+}
+
+/** Every field named in any declared index (composite indexes credit all fields). */
+export function coveredFields(indexes?: IndexDef[]): Set<string> {
+  const covered = new Set<string>();
+  for (const idx of indexes ?? []) {
+    for (const field of Object.keys(idx.fields)) covered.add(field);
+  }
+  return covered;
+}
+
+export function assertIndexed(
+  collection: string,
+  indexes: IndexDef[] | undefined,
+  filter?: Record<string, unknown>,
+  sort?: Record<string, 1 | -1>,
+  opts?: { allowScan?: boolean },
+): void {
+  if (opts?.allowScan) return;
+  const covered = coveredFields(indexes);
+
+  const fields = new Set<string>();
+  if (filter) for (const f of collectJsonFields(filter)) fields.add(f);
+  if (sort) {
+    for (const f of Object.keys(sort)) {
+      if (!TOP_LEVEL_COLUMNS.has(f)) fields.add(f);
+    }
+  }
+
+  for (const field of fields) {
+    if (!covered.has(field)) throw new UnindexedQueryError(collection, field);
+  }
+}

package/src/server/sqlite/sqliteUpdateOps.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { applyOpInMemory } from './sqliteUpdateOps.js';
+
+describe('applyOpInMemory', () => {
+  it('$set sets a top-level field', () => {
+    expect(applyOpInMemory({ a: 1 }, { $set: { b: 2 } })).toEqual({ a: 1, b: 2 });
+  });
+
+  it('$set creates missing parent objects for a dot-path', () => {
+    expect(applyOpInMemory({}, { $set: { 'x.y.z': 5 } })).toEqual({
+      x: { y: { z: 5 } },
+    });
+  });
+
+  it('$unset removes a top-level key', () => {
+    expect(applyOpInMemory({ a: 1, b: 2 }, { $unset: { b: '' } })).toEqual({ a: 1 });
+  });
+
+  it('$unset removes a nested key, leaving the parent', () => {
+    expect(
+      applyOpInMemory({ x: { y: 1, z: 2 } }, { $unset: { 'x.z': '' } }),
+    ).toEqual({ x: { y: 1 } });
+  });
+
+  it('$inc adds to an existing number', () => {
+    expect(applyOpInMemory({ n: 3 }, { $inc: { n: 2 } })).toEqual({ n: 5 });
+  });
+
+  it('$inc treats a missing field as 0', () => {
+    expect(applyOpInMemory({}, { $inc: { n: 4 } })).toEqual({ n: 4 });
+  });
+
+  it('$addToSet appends a new scalar', () => {
+    expect(applyOpInMemory({ tags: ['a'] }, { $addToSet: { tags: 'b' } })).toEqual({
+      tags: ['a', 'b'],
+    });
+  });
+
+  it('$addToSet is a no-op when the value is already present', () => {
+    expect(applyOpInMemory({ tags: ['a'] }, { $addToSet: { tags: 'a' } })).toEqual({
+      tags: ['a'],
+    });
+  });
+
+  it('$addToSet creates the array when the field is missing', () => {
+    expect(applyOpInMemory({}, { $addToSet: { tags: 'a' } })).toEqual({ tags: ['a'] });
+  });
+
+  it('$pull removes all deep-equal elements', () => {
+    expect(
+      applyOpInMemory({ tags: ['a', 'b', 'a'] }, { $pull: { tags: 'a' } }),
+    ).toEqual({ tags: ['b'] });
+  });
+
+  it('does not mutate the input object', () => {
+    const input = { a: 1 };
+    applyOpInMemory(input, { $set: { a: 2 } });
+    expect(input).toEqual({ a: 1 });
+  });
+
+  it('applies operators in $set,$unset,$inc,$addToSet,$pull order', () => {
+    expect(
+      applyOpInMemory(
+        { keep: 1, drop: 1, n: 1, tags: ['x'] },
+        {
+          $set: { added: 9 },
+          $unset: { drop: '' },
+          $inc: { n: 1 },
+          $addToSet: { tags: 'y' },
+        },
+      ),
+    ).toEqual({ keep: 1, added: 9, n: 2, tags: ['x', 'y'] });
+  });
+});

package/src/server/sqlite/sqliteUpdateOps.ts

@@ -0,0 +1,111 @@
+/**
+ * MongoDB-style update operators applied in-memory over a plain doc object.
+ * Mirrors PostgresOperators.buildUpdateExpression's SEMANTICS (not its SQL):
+ * the SQLite store does read-modify-write, so the resulting document must match
+ * what Postgres's jsonb_set UPDATE would produce. Pure — no DB, no native import.
+ */
+
+export interface UpdateOp {
+  $set?: Record<string, unknown>;
+  $unset?: Record<string, unknown>;
+  $inc?: Record<string, number>;
+  $addToSet?: Record<string, unknown>;
+  $pull?: Record<string, unknown>;
+}
+
+/** Structural deep-equality, mirroring Postgres jsonb `=` (key order irrelevant). */
+export function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === 'object') {
+    const ao = a as Record<string, unknown>;
+    const bo = b as Record<string, unknown>;
+    const ak = Object.keys(ao);
+    const bk = Object.keys(bo);
+    if (ak.length !== bk.length) return false;
+    return ak.every((k) => k in bo && deepEqual(ao[k], bo[k]));
+  }
+  return false;
+}
+
+function setPath(root: Record<string, unknown>, path: string, value: unknown): void {
+  const parts = path.split('.');
+  let node = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i]!;
+    const next = node[key];
+    if (typeof next !== 'object' || next === null || Array.isArray(next)) {
+      node[key] = {};
+    }
+    node = node[key] as Record<string, unknown>;
+  }
+  node[parts[parts.length - 1]!] = value;
+}
+
+function unsetPath(root: Record<string, unknown>, path: string): void {
+  const parts = path.split('.');
+  let node = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const next = node[parts[i]!];
+    if (typeof next !== 'object' || next === null) return;
+    node = next as Record<string, unknown>;
+  }
+  delete node[parts[parts.length - 1]!];
+}
+
+function getPath(root: Record<string, unknown>, path: string): unknown {
+  const parts = path.split('.');
+  let node: unknown = root;
+  for (const key of parts) {
+    if (typeof node !== 'object' || node === null) return undefined;
+    node = (node as Record<string, unknown>)[key];
+  }
+  return node;
+}
+
+export function applyOpInMemory(
+  data: Record<string, unknown>,
+  op: UpdateOp,
+): Record<string, unknown> {
+  const out = structuredClone(data);
+
+  if (op.$set) {
+    for (const [field, value] of Object.entries(op.$set)) setPath(out, field, value);
+  }
+  if (op.$unset) {
+    for (const field of Object.keys(op.$unset)) unsetPath(out, field);
+  }
+  if (op.$inc) {
+    for (const [field, amount] of Object.entries(op.$inc)) {
+      const cur = getPath(out, field);
+      const base = typeof cur === 'number' ? cur : 0;
+      setPath(out, field, base + amount);
+    }
+  }
+  if (op.$addToSet) {
+    for (const [field, value] of Object.entries(op.$addToSet)) {
+      const cur = getPath(out, field);
+      const arr = Array.isArray(cur) ? [...(cur as unknown[])] : [];
+      if (!arr.some((el) => deepEqual(el, value))) arr.push(value);
+      setPath(out, field, arr);
+    }
+  }
+  if (op.$pull) {
+    for (const [field, value] of Object.entries(op.$pull)) {
+      const cur = getPath(out, field);
+      const arr = Array.isArray(cur) ? (cur as unknown[]) : [];
+      setPath(
+        out,
+        field,
+        arr.filter((el) => !deepEqual(el, value)),
+      );
+    }
+  }
+
+  return out;
+}

package/src/shared/FrameworkRequests.ts

@@ -367,6 +367,7 @@ export const frameworkRequests = defineRequests({
         "dropped-frames",
         "long-task",
         "page-unload",
+        "page-load",
         "self-snapshot",
         "app-quit",
       ]),