@fragno-dev/db 0.2.1 → 0.3.0

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

@@ -0,0 +1,145 @@
+import type { AnyColumn, AnySchema, AnyTable } from "../../schema/create";
+import { SortedArrayIndex } from "./sorted-array-index";
+import { SQLocalDriverConfig } from "../generic-sql/driver-config";
+import { createSQLSerializer } from "../../query/serialize/create-sql-serializer";
+import { compareNormalizedValues } from "./value-comparison";
+import type { NamingResolver } from "../../naming/sql-naming";
+
+export type InMemoryRow = Record<string, unknown>;
+
+export type InMemoryIndexDefinition = {
+  name: string;
+  columnNames: string[];
+  unique: boolean;
+};
+
+export type InMemoryIndexStore = {
+  definition: InMemoryIndexDefinition;
+  index: SortedArrayIndex<bigint>;
+};
+
+export type InMemoryTableStore = {
+  rows: Map<bigint, InMemoryRow>;
+  nextInternalId: bigint;
+  indexes: Map<string, InMemoryIndexStore>;
+};
+
+export type InMemoryNamespaceStore = {
+  tables: Map<string, InMemoryTableStore>;
+};
+
+export type InMemoryStore = {
+  namespaces: Map<string, InMemoryNamespaceStore>;
+};
+
+const sqliteSerializer = createSQLSerializer(new SQLocalDriverConfig());
+
+export const normalizeIndexValue = (value: unknown, column: AnyColumn): unknown => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return sqliteSerializer.serialize(value, column);
+};
+
+export const buildIndexKey = (
+  table: AnyTable,
+  index: InMemoryIndexDefinition,
+  row: InMemoryRow,
+  resolver?: NamingResolver,
+): readonly unknown[] => {
+  const columnMap = resolver ? resolver.getColumnNameMap(table) : undefined;
+  return index.columnNames.map((columnName) => {
+    const logicalName = columnMap?.[columnName] ?? columnName;
+    const column = table.columns[logicalName];
+    if (!column) {
+      throw new Error(
+        `Column "${columnName}" not found in table "${table.name}" for index "${index.name}".`,
+      );
+    }
+    return normalizeIndexValue(row[columnName], column);
+  });
+};
+
+const createTableIndexes = (
+  table: AnyTable,
+  resolver?: NamingResolver,
+): Map<string, InMemoryIndexStore> => {
+  const indexes = new Map<string, InMemoryIndexStore>();
+  const primaryIndex = table.indexes["_primary"];
+  const primaryColumnNames = primaryIndex
+    ? primaryIndex.columnNames.map((columnName) =>
+        resolver ? resolver.getColumnName(table.name, columnName) : columnName,
+      )
+    : [
+        resolver
+          ? resolver.getColumnName(table.name, table.getIdColumn().name)
+          : table.getIdColumn().name,
+      ];
+  const primaryDefinition: InMemoryIndexDefinition = {
+    name: "_primary",
+    columnNames: primaryColumnNames,
+    unique: primaryIndex?.unique ?? true,
+  };
+  indexes.set("_primary", {
+    definition: primaryDefinition,
+    index: new SortedArrayIndex(compareNormalizedValues, { unique: primaryDefinition.unique }),
+  });
+
+  for (const [name, index] of Object.entries(table.indexes)) {
+    if (name === "_primary") {
+      continue;
+    }
+    indexes.set(name, {
+      definition: {
+        name,
+        columnNames: index.columnNames.map((columnName) =>
+          resolver ? resolver.getColumnName(table.name, columnName) : columnName,
+        ),
+        unique: index.unique,
+      },
+      index: new SortedArrayIndex(compareNormalizedValues, { unique: index.unique }),
+    });
+  }
+
+  return indexes;
+};
+
+const createTableStore = (table: AnyTable, resolver?: NamingResolver): InMemoryTableStore => ({
+  rows: new Map(),
+  nextInternalId: 1n,
+  indexes: createTableIndexes(table, resolver),
+});
+
+export const createNamespaceStore = (
+  schema: AnySchema,
+  resolver?: NamingResolver,
+): InMemoryNamespaceStore => {
+  const tables = new Map<string, InMemoryTableStore>();
+  for (const tableName of Object.keys(schema.tables)) {
+    const table = schema.tables[tableName];
+    const storeKey = resolver ? resolver.getTableName(table.name) : table.name;
+    tables.set(storeKey, createTableStore(table, resolver));
+  }
+
+  return { tables };
+};
+
+export const createInMemoryStore = (): InMemoryStore => ({
+  namespaces: new Map(),
+});
+
+export const ensureNamespaceStore = (
+  store: InMemoryStore,
+  namespace: string,
+  schema: AnySchema,
+  resolver?: NamingResolver,
+): InMemoryNamespaceStore => {
+  const existing = store.namespaces.get(namespace);
+  if (existing) {
+    return existing;
+  }
+
+  const created = createNamespaceStore(schema, resolver);
+  store.namespaces.set(namespace, created);
+  return created;
+};

package/src/adapters/in-memory/value-comparison.ts

@@ -0,0 +1,53 @@
+const asBuffer = (value: unknown): Buffer | undefined => {
+  if (value instanceof Buffer) {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return Buffer.from(value);
+  }
+  return undefined;
+};
+
+export const compareNormalizedValues = (left: unknown, right: unknown): number => {
+  if (left === right) {
+    return 0;
+  }
+  if (left === undefined) {
+    return -1;
+  }
+  if (right === undefined) {
+    return 1;
+  }
+  if (left === null) {
+    return -1;
+  }
+  if (right === null) {
+    return 1;
+  }
+  const leftBuffer = asBuffer(left);
+  const rightBuffer = asBuffer(right);
+  if (leftBuffer && rightBuffer) {
+    return Buffer.compare(leftBuffer, rightBuffer);
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() - right.getTime();
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return left - right;
+  }
+  if (typeof left === "bigint" && typeof right === "bigint") {
+    return left < right ? -1 : 1;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left < right ? -1 : 1;
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return left === right ? 0 : left ? 1 : -1;
+  }
+  const leftString = String(left);
+  const rightString = String(right);
+  return leftString < rightString ? -1 : leftString > rightString ? 1 : 0;
+};

package/src/adapters/in-memory/value-normalization.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import { buildIndexKey } from "./store";
+
+const testSchema = schema("test", (s) =>
+  s.addTable("events", (t) =>
+    t
+      .addColumn("id", idColumn())
+      .addColumn("createdAt", column("timestamp"))
+      .addColumn("isActive", column("bool"))
+      .addColumn("payload", column("json"))
+      .addColumn("size", column("bigint"))
+      .addColumn("userId", referenceColumn())
+      .createIndex("compound_idx", ["createdAt", "isActive", "payload", "size", "userId"]),
+  ),
+);
+
+describe("in-memory index normalization", () => {
+  it("normalizes index keys using SQLite serializer semantics", () => {
+    const table = testSchema.tables.events;
+    const index = table.indexes["compound_idx"];
+    if (!index) {
+      throw new Error("compound_idx missing from schema");
+    }
+
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const payload = { ok: true, count: 2 };
+    const size = 9n;
+    const userId = 12n;
+
+    const row = {
+      id: "evt_1",
+      createdAt,
+      isActive: true,
+      payload,
+      size,
+      userId,
+    };
+
+    const key = buildIndexKey(
+      table,
+      { name: index.name, columnNames: [...index.columnNames], unique: index.unique },
+      row,
+    );
+
+    const expectedBigint = Buffer.alloc(8);
+    expectedBigint.writeBigInt64BE(size);
+
+    expect(key).toEqual([
+      createdAt.getTime(),
+      1,
+      JSON.stringify(payload),
+      expectedBigint,
+      Number(userId),
+    ]);
+  });
+});