@fragno-dev/db 0.2.2 → 0.3.0

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";
+  }
+}

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

@@ -0,0 +1,277 @@
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import {
+  fragnoDatabaseAdapterNameFakeSymbol,
+  fragnoDatabaseAdapterVersionFakeSymbol,
+  type DatabaseAdapter,
+  type DatabaseContextStorage,
+} from "../adapters";
+import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
+import type { SimpleQueryInterface, TableToUpdateValues } from "../../query/simple-query-interface";
+import {
+  resolveInMemoryAdapterOptions,
+  type InMemoryAdapterOptions,
+  type ResolvedInMemoryAdapterOptions,
+} from "./options";
+import { createInMemoryStore, ensureNamespaceStore } from "./store";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { UnitOfWork, type UnitOfWorkConfig } from "../../query/unit-of-work/unit-of-work";
+import type { CursorResult } from "../../query/cursor";
+import {
+  createNamingResolver,
+  suffixNamingStrategy,
+  type SqlNamingStrategy,
+} from "../../naming/sql-naming";
+
+class UpdateManySpecialBuilder<TTable extends AnyTable> {
+  #indexName?: string;
+  #condition?: unknown;
+  #setValues?: TableToUpdateValues<TTable>;
+
+  whereIndex(indexName: string, condition?: unknown): this {
+    this.#indexName = indexName;
+    this.#condition = condition;
+    return this;
+  }
+
+  set(values: TableToUpdateValues<TTable>): this {
+    this.#setValues = values;
+    return this;
+  }
+
+  getConfig() {
+    return {
+      indexName: this.#indexName,
+      condition: this.#condition,
+      setValues: this.#setValues,
+    };
+  }
+}
+
+const hasIdField = (record: unknown): record is { id: string | FragnoId } =>
+  record !== null && typeof record === "object" && "id" in record;
+
+export type InMemoryUowConfig = UnitOfWorkConfig;
+
+export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
+  readonly options: ResolvedInMemoryAdapterOptions;
+  readonly namingStrategy: SqlNamingStrategy;
+
+  #contextStorage: RequestContextStorage<DatabaseContextStorage>;
+  #store = createInMemoryStore();
+  #schemaNamespaceMap = new WeakMap<AnySchema, string | null>();
+  #schemaByNamespace = new Map<string, { schema: AnySchema; namespace: string | null }>();
+
+  constructor(options: InMemoryAdapterOptions = {}) {
+    this.options = resolveInMemoryAdapterOptions(options);
+    this.namingStrategy = options.namingStrategy ?? suffixNamingStrategy;
+    this.#contextStorage = new RequestContextStorage();
+  }
+
+  get [fragnoDatabaseAdapterNameFakeSymbol](): string {
+    return "in-memory";
+  }
+
+  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
+    return 0;
+  }
+
+  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
+    return this.#contextStorage;
+  }
+
+  async getSchemaVersion(_namespace: string): Promise<string | undefined> {
+    return undefined;
+  }
+
+  async isConnectionHealthy(): Promise<boolean> {
+    return true;
+  }
+
+  async close(): Promise<void> {
+    return;
+  }
+
+  async reset(): Promise<void> {
+    this.#store.namespaces.clear();
+    for (const [namespaceKey, { schema, namespace }] of this.#schemaByNamespace) {
+      const resolver = createNamingResolver(schema, namespace, this.namingStrategy);
+      ensureNamespaceStore(this.#store, namespaceKey, schema, resolver);
+    }
+  }
+
+  createQueryEngine<T extends AnySchema>(
+    schema: T,
+    namespace: string | null,
+  ): SimpleQueryInterface<T, InMemoryUowConfig> {
+    this.#schemaNamespaceMap.set(schema, namespace);
+    const namespaceKey = namespace ?? schema.name;
+    this.#schemaByNamespace.set(namespaceKey, { schema, namespace });
+    const resolverFactory = (schemaForResolver: AnySchema, namespaceForResolver: string | null) =>
+      createNamingResolver(schemaForResolver, namespaceForResolver, this.namingStrategy);
+    const resolver = resolverFactory(schema, namespace);
+    ensureNamespaceStore(this.#store, namespaceKey, schema, resolver);
+
+    const compiler = createInMemoryUowCompiler();
+    const executor = createInMemoryUowExecutor(this.#store, this.options, resolverFactory);
+    const decoder = new InMemoryUowDecoder(resolverFactory);
+
+    const createUow = (opts?: { name?: string; config?: UnitOfWorkConfig }) =>
+      new UnitOfWork(
+        compiler,
+        executor,
+        decoder,
+        opts?.name,
+        opts?.config,
+        this.#schemaNamespaceMap,
+      ).forSchema(schema);
+
+    const queryEngine = {
+      now: async () => this.options.clock.now(),
+      async find(tableName, builderFn) {
+        const uow = createUow();
+        uow.find(tableName, builderFn);
+        const [result]: unknown[][] = await uow.executeRetrieve();
+        return result ?? [];
+      },
+
+      async findWithCursor(tableName, builderFn) {
+        const uow = createUow().findWithCursor(tableName, builderFn);
+        const [result] = await uow.executeRetrieve();
+        return result as CursorResult<unknown>;
+      },
+
+      async findFirst(tableName, builderFn) {
+        const uow = createUow();
+        if (builderFn) {
+          uow.find(tableName, (b) => {
+            builderFn(b);
+            return b.pageSize(1);
+          });
+        } else {
+          uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
+        }
+        const [result]: unknown[][] = await uow.executeRetrieve();
+        return result?.[0] ?? null;
+      },
+
+      async create(tableName, values) {
+        const uow = createUow();
+        uow.create(tableName, values);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to create record");
+        }
+
+        const createdId = uow.getCreatedIds()[0];
+        if (!createdId) {
+          throw new Error("Failed to get created ID");
+        }
+        return createdId;
+      },
+
+      async createMany(tableName, valuesArray) {
+        const uow = createUow();
+        for (const values of valuesArray) {
+          uow.create(tableName, values);
+        }
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to create records");
+        }
+        return uow.getCreatedIds();
+      },
+
+      async update(tableName, id, builderFn) {
+        const uow = createUow();
+        uow.update(tableName, id, builderFn);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to update record (version conflict or record not found)");
+        }
+      },
+
+      async updateMany(tableName, builderFn) {
+        const table = schema.tables[tableName];
+        if (!table) {
+          throw new Error(`Table ${tableName} not found in schema`);
+        }
+
+        const specialBuilder = new UpdateManySpecialBuilder<typeof table>();
+        builderFn(specialBuilder);
+        const { indexName, condition, setValues } = specialBuilder.getConfig();
+
+        if (!indexName) {
+          throw new Error("whereIndex() must be called in updateMany");
+        }
+        if (!setValues) {
+          throw new Error("set() must be called in updateMany");
+        }
+
+        const findUow = createUow();
+        findUow.find(tableName, (b) => {
+          if (condition !== undefined && condition !== null) {
+            return b.whereIndex(indexName as never, condition as never);
+          }
+          return b.whereIndex(indexName as never);
+        });
+        const [records]: unknown[][] = await findUow.executeRetrieve();
+
+        if (!records || records.length === 0) {
+          return;
+        }
+
+        const updateUow = createUow();
+        for (const record of records) {
+          if (!hasIdField(record)) {
+            throw new Error("Record missing id field");
+          }
+          updateUow.update(tableName, record.id, (b) => b.set(setValues).check());
+        }
+        const { success } = await updateUow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to update records (version conflict)");
+        }
+      },
+
+      async delete(tableName, id, builderFn) {
+        const uow = createUow();
+        uow.delete(tableName, id, builderFn);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to delete record (version conflict or record not found)");
+        }
+      },
+
+      async deleteMany(tableName, builderFn) {
+        const findUow = createUow();
+        findUow.find(tableName, builderFn);
+        const [records]: unknown[][] = await findUow.executeRetrieve();
+
+        if (!records || records.length === 0) {
+          return;
+        }
+
+        const deleteUow = createUow();
+        for (const record of records) {
+          if (!hasIdField(record)) {
+            throw new Error("Record missing id field");
+          }
+          deleteUow.delete(tableName, record.id);
+        }
+        const { success } = await deleteUow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to delete records (version conflict)");
+        }
+      },
+
+      createUnitOfWork(name, config) {
+        return createUow({ name, config });
+      },
+    } as SimpleQueryInterface<T, InMemoryUowConfig>;
+    return queryEngine;
+  }
+}