@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/in-memory/condition-evaluator.test.ts

@@ -0,0 +1,193 @@
+import { describe, expect, it } from "vitest";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import type { Condition } from "../../query/condition-builder";
+import { buildCondition } from "../../query/condition-builder";
+import { evaluateCondition } from "./condition-evaluator";
+import { createNamespaceStore } from "./store";
+
+describe("in-memory condition evaluator", () => {
+  it("evaluates SQLite-normalized comparisons and LIKE semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("isActive", column("bool"))
+          .addColumn("payload", column("json"))
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const payload = { ok: true, count: 2 };
+    const row = {
+      id: "evt_1",
+      name: "Test User",
+      createdAt,
+      isActive: true,
+      payload,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("createdAt", "=", createdAt)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    const numericBooleanCondition: Condition = {
+      type: "compare",
+      a: table.columns.isActive,
+      operator: "=",
+      b: 1,
+    };
+    expect(evaluateCondition(numericBooleanCondition, table, row)).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("payload", "=", payload)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", ">", 8n)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "contains", "test")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "starts with", "TEST")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "ends with", "user")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("handles null and IN semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("age", column("integer").nullable())
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const row = {
+      id: "evt_2",
+      age: null,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is", null)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "=", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is not", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+
+    const inCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "in",
+      b: [1n, null],
+    };
+    const notInCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "not in",
+      b: [1n, null],
+    };
+
+    expect(evaluateCondition(inCondition, table, row)).toBe(false);
+    expect(evaluateCondition(notInCondition, table, row)).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", "not in", [1n, 2n])),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("resolves reference values against the namespace store", () => {
+    const refSchema = schema("ref", (s) =>
+      s
+        .addTable("users", (t) =>
+          t.addColumn("id", idColumn()).addColumn("email", column("string")),
+        )
+        .addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("userId", referenceColumn()),
+        )
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "userId" },
+          to: { table: "users", column: "id" },
+        }),
+    );
+
+    const namespaceStore = createNamespaceStore(refSchema);
+    const usersStore = namespaceStore.tables.get("users");
+    const postsTable = refSchema.tables.posts;
+
+    if (!usersStore) {
+      throw new Error("users table missing from namespace store");
+    }
+
+    usersStore.rows.set(1n, {
+      id: "user_1",
+      email: "user@example.com",
+      _internalId: 1n,
+      _version: 0,
+    });
+
+    const postRow = {
+      id: "post_1",
+      title: "Hello",
+      userId: 1n,
+      _internalId: 10n,
+      _version: 0,
+    };
+
+    const condition = buildCondition(postsTable.columns, (eb) => eb("userId", "=", "user_1"));
+    expect(evaluateCondition(condition, postsTable, postRow, namespaceStore)).toBe(true);
+  });
+});

package/src/adapters/in-memory/condition-evaluator.ts

@@ -0,0 +1,275 @@
+import type { Condition } from "../../query/condition-builder";
+import { ReferenceSubquery, resolveFragnoIdValue } from "../../query/value-encoding";
+import { isDbNow } from "../../query/db-now";
+import type { AnyColumn, AnyTable } from "../../schema/create";
+import { Column, FragnoId, FragnoReference } from "../../schema/create";
+import type { InMemoryNamespaceStore, InMemoryRow } from "./store";
+import { normalizeIndexValue } from "./store";
+import { resolveReferenceSubquery } from "./reference-resolution";
+import { compareNormalizedValues } from "./value-comparison";
+import type { NamingResolver } from "../../naming/sql-naming";
+
+const isNullish = (value: unknown): value is null | undefined =>
+  value === null || value === undefined;
+
+const resolveReferenceValue = (
+  value: unknown,
+  column: AnyColumn,
+  table: AnyTable,
+  namespaceStore?: InMemoryNamespaceStore,
+  resolver?: NamingResolver,
+): unknown => {
+  if (value instanceof FragnoReference) {
+    return value.internalId;
+  }
+
+  if (value instanceof FragnoId) {
+    if (value.internalId !== undefined) {
+      return value.internalId;
+    }
+    return resolveReferenceValue(value.externalId, column, table, namespaceStore, resolver);
+  }
+
+  if (value instanceof ReferenceSubquery) {
+    if (!namespaceStore) {
+      throw new Error("In-memory condition evaluation requires a namespace store.");
+    }
+    return resolveReferenceSubquery(namespaceStore, value, resolver);
+  }
+
+  if (typeof value === "string") {
+    if (!namespaceStore) {
+      throw new Error("In-memory condition evaluation requires a namespace store.");
+    }
+
+    const relation = Object.values(table.relations).find((rel) =>
+      rel.on.some(([localCol]) => localCol === column.name),
+    );
+    if (!relation) {
+      throw new Error(`Missing relation for reference column "${column.name}".`);
+    }
+
+    return resolveReferenceSubquery(
+      namespaceStore,
+      new ReferenceSubquery(relation.table, value),
+      resolver,
+    );
+  }
+
+  return resolveFragnoIdValue(value, column);
+};
+
+const resolveComparisonValue = (
+  value: unknown,
+  column: AnyColumn,
+  table: AnyTable,
+  row: InMemoryRow,
+  namespaceStore?: InMemoryNamespaceStore,
+  resolver?: NamingResolver,
+  now: () => Date = () => new Date(),
+): { value: unknown; column: AnyColumn } => {
+  if (value instanceof Column) {
+    const columnName = resolver ? resolver.getColumnName(table.name, value.name) : value.name;
+    return { value: row[columnName], column: value };
+  }
+
+  if (isDbNow(value)) {
+    return { value: now(), column };
+  }
+
+  if (column.role === "reference") {
+    return {
+      value: resolveReferenceValue(value, column, table, namespaceStore, resolver),
+      column,
+    };
+  }
+
+  return { value: resolveFragnoIdValue(value, column), column };
+};
+
+const normalizeLikeValue = (value: unknown, column: AnyColumn): string | null => {
+  const normalized = normalizeIndexValue(value, column);
+  if (normalized === null || normalized === undefined) {
+    return null;
+  }
+  if (normalized instanceof Buffer) {
+    return normalized.toString("hex");
+  }
+  return String(normalized);
+};
+
+const compareNormalized = (left: unknown, right: unknown): number =>
+  compareNormalizedValues(left, right);
+
+export const evaluateCondition = (
+  condition: Condition | boolean,
+  table: AnyTable,
+  row: InMemoryRow,
+  namespaceStore?: InMemoryNamespaceStore,
+  resolver?: NamingResolver,
+  now: () => Date = () => new Date(),
+): boolean => {
+  if (typeof condition === "boolean") {
+    return condition;
+  }
+
+  switch (condition.type) {
+    case "and": {
+      for (const item of condition.items) {
+        if (!evaluateCondition(item, table, row, namespaceStore, resolver, now)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case "or": {
+      for (const item of condition.items) {
+        if (evaluateCondition(item, table, row, namespaceStore, resolver, now)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case "not":
+      return !evaluateCondition(condition.item, table, row, namespaceStore, resolver, now);
+    case "compare":
+      break;
+    default: {
+      const exhaustiveCheck: never = condition;
+      throw new Error(`Unsupported condition type: ${JSON.stringify(exhaustiveCheck)}`);
+    }
+  }
+
+  const leftColumn = condition.a;
+  const leftColumnName = resolver
+    ? resolver.getColumnName(table.name, leftColumn.name)
+    : leftColumn.name;
+  const leftValue = row[leftColumnName];
+  const right = resolveComparisonValue(
+    condition.b,
+    leftColumn,
+    table,
+    row,
+    namespaceStore,
+    resolver,
+    now,
+  );
+
+  const op = condition.operator;
+  const rightValue = right.value;
+
+  if (op === "is" || op === "is not") {
+    if (isNullish(rightValue)) {
+      const matches = isNullish(leftValue);
+      return op === "is" ? matches : !matches;
+    }
+
+    if (isNullish(leftValue)) {
+      return op === "is not";
+    }
+
+    const leftNormalized = normalizeIndexValue(leftValue, leftColumn);
+    const rightNormalized = normalizeIndexValue(rightValue, right.column);
+    const matches = compareNormalized(leftNormalized, rightNormalized) === 0;
+    return op === "is" ? matches : !matches;
+  }
+
+  if (isNullish(leftValue) || isNullish(rightValue)) {
+    return false;
+  }
+
+  if (op === "in" || op === "not in") {
+    if (!Array.isArray(rightValue)) {
+      throw new Error(`Operator "${op}" expects an array value.`);
+    }
+
+    const leftNormalized = normalizeIndexValue(leftValue, leftColumn);
+    let hasNull = false;
+    let hasMatch = false;
+
+    for (const item of rightValue) {
+      const resolved = resolveComparisonValue(
+        item,
+        leftColumn,
+        table,
+        row,
+        namespaceStore,
+        resolver,
+        now,
+      );
+      if (isNullish(resolved.value)) {
+        hasNull = true;
+        continue;
+      }
+      const normalized = normalizeIndexValue(resolved.value, leftColumn);
+      if (compareNormalized(leftNormalized, normalized) === 0) {
+        hasMatch = true;
+        break;
+      }
+    }
+
+    if (hasMatch) {
+      return op === "in";
+    }
+
+    if (hasNull) {
+      return false;
+    }
+
+    return op === "not in";
+  }
+
+  if (
+    op === "contains" ||
+    op === "starts with" ||
+    op === "ends with" ||
+    op === "not contains" ||
+    op === "not starts with" ||
+    op === "not ends with"
+  ) {
+    const leftLike = normalizeLikeValue(leftValue, leftColumn);
+    const rightLike = normalizeLikeValue(rightValue, right.column);
+
+    if (leftLike === null || rightLike === null) {
+      return false;
+    }
+
+    const leftText = leftLike.toLowerCase();
+    const rightText = rightLike.toLowerCase();
+    let matches = false;
+
+    if (op.includes("contains")) {
+      matches = leftText.includes(rightText);
+    } else if (op.includes("starts with")) {
+      matches = leftText.startsWith(rightText);
+    } else {
+      matches = leftText.endsWith(rightText);
+    }
+
+    if (op.startsWith("not ")) {
+      return !matches;
+    }
+    return matches;
+  }
+
+  const leftNormalized = normalizeIndexValue(leftValue, leftColumn);
+  const rightNormalized = normalizeIndexValue(rightValue, right.column);
+  const comparison = compareNormalized(leftNormalized, rightNormalized);
+
+  switch (op) {
+    case "=":
+      return comparison === 0;
+    case "!=":
+      return comparison !== 0;
+    case ">":
+      return comparison > 0;
+    case ">=":
+      return comparison >= 0;
+    case "<":
+      return comparison < 0;
+    case "<=":
+      return comparison <= 0;
+    default:
+      throw new Error(`Unsupported operator "${op}".`);
+  }
+};

package/src/adapters/in-memory/errors.ts

@@ -0,0 +1,20 @@
+export class UniqueConstraintError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UniqueConstraintError";
+  }
+}
+
+export class ForeignKeyConstraintError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ForeignKeyConstraintError";
+  }
+}
+
+export class NotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}