@fragno-dev/db 0.3.0 → 0.4.1

package/src/mod.ts

@@ -1,25 +1,31 @@
+import type { FragnoInstantiatedFragment } from "@fragno-dev/core";
+
 import type { DatabaseAdapter } from "./adapters/adapters";
-import type { AnySchema } from "./schema/create";
-import type { CursorResult } from "./query/cursor";
-import { Cursor } from "./query/cursor";
-import { dbNow, type DbNow } from "./query/db-now";
-import type { FragnoInstantiatedFragment, AnyFragnoInstantiatedFragment } from "@fragno-dev/core";
 import type {
   FragnoPublicConfigWithDatabase,
   ImplicitDatabaseDependencies,
+  DatabaseHandlerContext,
 } from "./db-fragment-definition-builder";
+import { getSchemaVersionFromDatabase } from "./fragments/internal-fragment";
+import { getInternalFragment } from "./internal/adapter-registry";
+import type { CursorResult } from "./query/cursor";
+import { Cursor } from "./query/cursor";
 import {
-  getSchemaVersionFromDatabase,
-  type InternalFragmentInstance,
-} from "./fragments/internal-fragment";
-import { resolveDatabaseAdapter } from "./util/default-database-adapter";
+  dbInterval,
+  dbNow,
+  type DbInterval,
+  type DbIntervalInput,
+  type DbNow,
+} from "./query/db-now";
+import type { AnySchema } from "./schema/create";
 
 export type { DatabaseAdapter, CursorResult };
 export { Cursor };
-export { dbNow };
-export type { DbNow };
+export { dbNow, dbInterval };
+export type { DbNow, DbInterval, DbIntervalInput };
 export { InMemoryAdapter, type InMemoryAdapterOptions } from "./adapters/in-memory";
 export { internalSchema } from "./fragments/internal-fragment";
+export { getInternalFragment } from "./internal/adapter-registry";
 
 export const fragnoDatabaseFakeSymbol = "$fragno-database" as const;
 export const fragnoDatabaseLibraryVersion = "0.1" as const;
@@ -82,6 +88,7 @@ export class FragnoDatabase<const T extends AnySchema, TUOWConfig = void> {
 
 export {
   DatabaseFragmentDefinitionBuilder,
+  type DbRoundtripGuardConfig,
   type FragnoPublicConfigWithDatabase,
   type DatabaseFragmentContext,
   type DatabaseServiceContext,
@@ -118,8 +125,10 @@ export {
   HandlerTxBuilder,
   createServiceTxBuilder,
   createHandlerTxBuilder,
+  serviceCalls,
   type TxResult,
   // Builder context types
+  type HandlerTxContext,
   type ServiceBuilderMutateContext,
   type HandlerBuilderMutateContext,
   type BuilderTransformContextWithMutate,
@@ -144,6 +153,7 @@ export type {
   HookContext,
   HooksMap,
   HookFn,
+  HookHandlerTx,
   HookPayload,
   TriggerHookOptions,
   DurableHooksProcessingOptions,
@@ -151,10 +161,25 @@ export type {
   StuckHookProcessingEvent,
   StuckHookProcessingTimeoutMinutes,
 } from "./hooks/hooks";
-export {
-  createDurableHooksProcessor,
-  type DurableHooksProcessor,
-} from "./hooks/durable-hooks-processor";
+export { defineSyncCommands } from "./sync/commands";
+export type {
+  DurableHookRecord,
+  DurableHookStatus,
+  DurableHooksAccessor,
+  DurableHooksService,
+} from "./durable-hooks";
+export { getDurableHooksService } from "./durable-hooks";
+export type {
+  SubmitAppliedResponse,
+  SubmitConflictReason,
+  SubmitConflictResponse,
+  SubmitRequest,
+  SubmitResponse,
+  SyncCommandDefinition,
+  SyncCommandHandler,
+  SyncCommandRegistry,
+  SyncCommandTxFactory,
+} from "./sync/types";
 
 export type AnyFragnoInstantiatedDatabaseFragment<TSchema extends AnySchema = AnySchema> =
   FragnoInstantiatedFragment<
@@ -165,13 +190,10 @@ export type AnyFragnoInstantiatedDatabaseFragment<TSchema extends AnySchema = An
     any,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
+    DatabaseHandlerContext,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    any,
-    FragnoPublicConfigWithDatabase,
-    // Ensure the fragment has the internal fragment linked
-    { _fragno_internal: InternalFragmentInstance } & Record<string, AnyFragnoInstantiatedFragment>
+    FragnoPublicConfigWithDatabase
   >;
 
 /**
@@ -199,8 +221,8 @@ export type AnyFragnoInstantiatedDatabaseFragment<TSchema extends AnySchema = An
 export async function migrate<TSchema extends AnySchema>(
   fragment: AnyFragnoInstantiatedDatabaseFragment<TSchema>,
 ): Promise<void> {
-  const { options, deps, linkedFragments } = fragment.$internal;
-  const adapter = resolveDatabaseAdapter(options, deps.schema);
+  const { deps } = fragment.$internal;
+  const adapter = deps.databaseAdapter;
 
   // Check if adapter supports prepareMigrations
   if (!adapter.prepareMigrations) {
@@ -213,11 +235,7 @@ export async function migrate<TSchema extends AnySchema>(
   const namespace = deps.namespace ?? schema.name;
 
   // Step 1: Ensure the internal fragment (settings table) is migrated first
-  const internalFragment = linkedFragments._fragno_internal;
-
-  if (!internalFragment) {
-    throw new Error("Internal fragment not found. Please ensure the internal fragment is linked.");
-  }
+  const internalFragment = getInternalFragment(adapter);
 
   if (!(await adapter.isConnectionHealthy())) {
     throw new Error(

package/src/naming/sql-naming.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+
 import type { AnySchema, AnyTable } from "../schema/create";
 
 export type NamespaceScope = "suffix" | "schema";

package/src/outbox/outbox-builder.ts

@@ -1,7 +1,7 @@
+import { internalSchema } from "../fragments/internal-fragment.schema";
 import type { MutationOperation } from "../query/unit-of-work/unit-of-work";
 import type { AnySchema, AnyTable } from "../schema/create";
 import { FragnoId, FragnoReference } from "../schema/create";
-import { internalSchema } from "../fragments/internal-fragment.schema";
 import type { OutboxRefLookup, OutboxPayload, OutboxMutation } from "./outbox";
 import { encodeVersionstamp, versionstampToHex } from "./outbox";
 
@@ -91,7 +91,7 @@ export function buildOutboxPlan(operations: MutationOperation<AnySchema>[]): Out
 export function finalizeOutboxPayload(plan: OutboxPlan, transactionVersion: bigint): OutboxPayload {
   const mutations: OutboxMutation[] = plan.drafts.map((draft, index) => {
     const versionstamp = versionstampToHex(encodeVersionstamp(transactionVersion, index));
-    return { ...draft, versionstamp } as OutboxMutation;
+    return { ...draft, versionstamp };
   });
 
   return {

package/src/outbox/outbox.test.ts

@@ -1,16 +1,22 @@
 import { describe, expect, it } from "vitest";
-import { defineFragment, instantiate } from "@fragno-dev/core";
-import { SQLocalKysely } from "sqlocal/kysely";
+
 import { KyselyPGlite } from "kysely-pglite";
-import { PGlite } from "@electric-sql/pglite";
+import { SQLocalKysely } from "sqlocal/kysely";
 import superjson, { type SuperJSONResult } from "superjson";
-import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
+
+import { defineFragment, instantiate } from "@fragno-dev/core";
+
+import { PGlite } from "@electric-sql/pglite";
+
 import { PGLiteDriverConfig, SQLocalDriverConfig } from "../adapters/generic-sql/driver-config";
-import type { SimpleQueryInterface } from "../query/simple-query-interface";
-import { withDatabase } from "../with-database";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
 import { internalSchema, type InternalFragmentInstance } from "../fragments/internal-fragment";
+import { getInternalFragment } from "../internal/adapter-registry";
+import type { AnyFragnoInstantiatedDatabaseFragment, DatabaseRequestContext } from "../mod";
+import type { AnySchema } from "../schema/create";
 import { schema, idColumn, column, referenceColumn, FragnoReference } from "../schema/create";
-import type { OutboxConfig, OutboxEntry, OutboxPayload } from "./outbox";
+import { withDatabase } from "../with-database";
+import type { OutboxEntry, OutboxPayload } from "./outbox";
 
 const outboxSchema = schema("outbox", (s) => {
   return s
@@ -33,24 +39,36 @@ const outboxSchema = schema("outbox", (s) => {
     });
 });
 
+const alphaSchema = schema("alpha", (s) =>
+  s.addTable("alpha_items", (t) =>
+    t.addColumn("id", idColumn()).addColumn("name", column("string")),
+  ),
+);
+
+const betaSchema = schema("beta", (s) =>
+  s.addTable("beta_items", (t) =>
+    t.addColumn("id", idColumn()).addColumn("title", column("string")),
+  ),
+);
+
 const outboxFragmentName = "outbox-test";
 const outboxFragmentDef = defineFragment(outboxFragmentName)
   .extend(withDatabase(outboxSchema))
   .build();
 
 type OutboxAdapterConfig =
-  | { type: "kysely-sqlite"; outbox?: OutboxConfig }
-  | { type: "kysely-pglite"; outbox?: OutboxConfig };
+  | { type: "kysely-sqlite"; outboxEnabled?: boolean }
+  | { type: "kysely-pglite"; outboxEnabled?: boolean };
 
 type OutboxTestContext = {
-  db: SimpleQueryInterface<typeof outboxSchema>;
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>;
   internalFragment: InternalFragmentInstance;
   cleanup: () => Promise<void>;
 };
 
 async function migrateSchema(
   adapter: SqlAdapter,
-  schemaToMigrate: typeof outboxSchema | typeof internalSchema,
+  schemaToMigrate: AnySchema,
   namespace: string,
 ): Promise<void> {
   const migrations = adapter.prepareMigrations(schemaToMigrate, namespace);
@@ -66,7 +84,6 @@ async function createAdapter(config: OutboxAdapterConfig): Promise<{
     const adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
-      outbox: config.outbox,
     });
 
     await migrateSchema(adapter, internalSchema, "");
@@ -85,7 +102,6 @@ async function createAdapter(config: OutboxAdapterConfig): Promise<{
   const adapter = new SqlAdapter({
     dialect,
     driverConfig: new PGLiteDriverConfig(),
-    outbox: config.outbox,
   });
 
   await migrateSchema(adapter, internalSchema, "");
@@ -104,13 +120,15 @@ async function buildOutboxTest(adapterConfig: OutboxAdapterConfig): Promise<Outb
   const fragment = instantiate(outboxFragmentDef)
     .withConfig({})
     .withRoutes([])
-    .withOptions({ databaseAdapter: adapter })
+    .withOptions({
+      databaseAdapter: adapter,
+      outbox: adapterConfig.outboxEnabled ? { enabled: true } : undefined,
+    })
     .build();
-  const deps = fragment.$internal.deps as { db: SimpleQueryInterface<typeof outboxSchema> };
 
   return {
-    db: deps.db,
-    internalFragment: fragment.$internal.linkedFragments._fragno_internal,
+    fragment,
+    internalFragment: getInternalFragment(adapter),
     cleanup,
   };
 }
@@ -119,7 +137,7 @@ async function listOutbox(
   internalFragment: InternalFragmentInstance,
   options?: { afterVersionstamp?: string; limit?: number },
 ): Promise<OutboxEntry[]> {
-  return internalFragment.inContext(async function () {
+  return internalFragment.inContext(async function (this: DatabaseRequestContext) {
     return (await this.handlerTx()
       .withServiceCalls(() => [internalFragment.services.outboxService.list(options)] as const)
       .transform(({ serviceResult: [result] }) => result)
@@ -127,39 +145,98 @@ async function listOutbox(
   });
 }
 
+async function listOutboxMutations(internalFragment: InternalFragmentInstance): Promise<
+  Array<{
+    entryVersionstamp: string;
+    mutationVersionstamp: string;
+    uowId: string;
+    schema: string;
+    table: string;
+    externalId: string;
+    op: string;
+  }>
+> {
+  return internalFragment.inContext(async function (this: DatabaseRequestContext) {
+    return await this.handlerTx()
+      .retrieve(({ forSchema }) =>
+        forSchema(internalSchema).find("fragno_db_outbox_mutations", (b) =>
+          b
+            .whereIndex("idx_outbox_mutations_entry")
+            .orderByIndex("idx_outbox_mutations_entry", "asc"),
+        ),
+      )
+      .transformRetrieve(([result]) => result)
+      .execute();
+  });
+}
+
+async function createUser(
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>,
+  email: string,
+) {
+  return fragment.inContext(async function (this: DatabaseRequestContext) {
+    await this.handlerTx()
+      .mutate(({ forSchema }) => forSchema(outboxSchema).create("users", { email }))
+      .execute();
+
+    const user = await this.handlerTx()
+      .retrieve(({ forSchema }) =>
+        forSchema(outboxSchema).findFirst("users", (b) =>
+          b.whereIndex("idx_users_email", (eb) => eb("email", "=", email)),
+        ),
+      )
+      .transformRetrieve(([result]) => result)
+      .execute();
+
+    if (!user) {
+      throw new Error("Expected user to be created.");
+    }
+
+    return user.id;
+  });
+}
+
+async function createPost(
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>,
+  title: string,
+  authorId: FragnoReference,
+) {
+  return fragment.inContext(async function (this: DatabaseRequestContext) {
+    return await this.handlerTx()
+      .mutate(({ forSchema }) => forSchema(outboxSchema).create("posts", { title, authorId }))
+      .transform(({ mutateResult }) => mutateResult)
+      .execute();
+  });
+}
+
 const adapterConfigs = [{ type: "kysely-sqlite" as const }, { type: "kysely-pglite" as const }];
 
 describe("Fragno DB Outbox", () => {
   it("does not write outbox entries when disabled", async () => {
-    const { db, internalFragment, cleanup } = await buildOutboxTest({
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
       type: "kysely-sqlite",
     });
 
-    await db.create("users", { email: "disabled@example.com" });
+    await createUser(fragment, "disabled@example.com");
 
     const entries = await listOutbox(internalFragment);
     expect(entries).toHaveLength(0);
+    const mutations = await listOutboxMutations(internalFragment);
+    expect(mutations).toHaveLength(0);
 
     await cleanup();
   });
 
   it("stores refMap placeholders and lists entries in order", async () => {
-    const { db, internalFragment, cleanup } = await buildOutboxTest({
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
       type: "kysely-sqlite",
-      outbox: { enabled: true },
+      outboxEnabled: true,
     });
 
-    await db.create("users", { email: "alpha@example.com" });
-    const user = await db.findFirst("users", (b) =>
-      b.whereIndex("idx_users_email", (eb) => eb("email", "=", "alpha@example.com")),
-    );
-    expect(user).not.toBeNull();
-    expect(user?.id.internalId).toBeDefined();
+    const userId = await createUser(fragment, "alpha@example.com");
+    expect(userId.internalId).toBeDefined();
 
-    await db.create("posts", {
-      title: "Hello",
-      authorId: FragnoReference.fromInternal(user!.id.internalId!),
-    });
+    await createPost(fragment, "Hello", FragnoReference.fromInternal(userId.internalId!));
 
     const entries = await listOutbox(internalFragment);
     expect(entries).toHaveLength(2);
@@ -183,10 +260,10 @@ describe("Fragno DB Outbox", () => {
       authorId: { __fragno_ref: "0.authorId" },
     });
     expect(entries[1].refMap).toEqual({
-      "0.authorId": user!.id.externalId,
+      "0.authorId": userId.externalId,
     });
 
-    await internalFragment.inContext(async function () {
+    await internalFragment.inContext(async function (this: DatabaseRequestContext) {
       await this.handlerTx()
         .withServiceCalls(() => [
           internalFragment.services.settingsService.set("outbox-test", "noop", "1"),
@@ -200,19 +277,60 @@ describe("Fragno DB Outbox", () => {
     await cleanup();
   });
 
+  it("writes mutation log rows for each outbox entry", async () => {
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
+      type: "kysely-sqlite",
+      outboxEnabled: true,
+    });
+
+    const userId = await createUser(fragment, "log-alpha@example.com");
+    expect(userId.internalId).toBeDefined();
+
+    await createPost(fragment, "Log", FragnoReference.fromInternal(userId.internalId!));
+
+    const entries = await listOutbox(internalFragment);
+    const mutations = await listOutboxMutations(internalFragment);
+
+    expect(entries).toHaveLength(2);
+    expect(mutations).toHaveLength(2);
+
+    const entryByVersion = new Map(entries.map((entry) => [entry.versionstamp, entry]));
+
+    for (const entry of entries) {
+      const payload = superjson.deserialize(entry.payload as SuperJSONResult) as OutboxPayload;
+      expect(payload.mutations).toHaveLength(1);
+    }
+
+    for (const mutationRow of mutations) {
+      const entry = entryByVersion.get(mutationRow.entryVersionstamp);
+      expect(entry).toBeDefined();
+      const payload = superjson.deserialize(entry!.payload as SuperJSONResult) as OutboxPayload;
+      const mutation = payload.mutations[0];
+      expect(mutationRow.mutationVersionstamp).toBe(mutation.versionstamp);
+      expect(mutationRow.uowId).toBe(entry!.uowId);
+      expect(mutationRow.schema).toBe(mutation.schema);
+      expect(mutationRow.table).toBe(mutation.table);
+      expect(mutationRow.externalId).toBe(mutation.externalId);
+      expect(mutationRow.op).toBe(mutation.op);
+    }
+
+    await cleanup();
+  });
+
   it("orders outbox entries by commit order across concurrent UOWs", async () => {
-    const { db, internalFragment, cleanup } = await buildOutboxTest({
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
       type: "kysely-sqlite",
-      outbox: { enabled: true },
+      outboxEnabled: true,
     });
 
-    const uow1 = db.createUnitOfWork("uow-1");
-    const uow2 = db.createUnitOfWork("uow-2");
+    const createUow = fragment.$internal.deps.createUnitOfWork;
+    const uow1 = createUow();
+    const uow2 = createUow();
     const uow1Id = uow1.idempotencyKey;
     const uow2Id = uow2.idempotencyKey;
 
-    uow1.create("users", { email: "order-1@example.com" });
-    uow2.create("users", { email: "order-2@example.com" });
+    uow1.forSchema(outboxSchema).create("users", { email: "order-1@example.com" });
+    uow2.forSchema(outboxSchema).create("users", { email: "order-2@example.com" });
 
     const completionOrder: string[] = [];
     await Promise.all([
@@ -227,24 +345,77 @@ describe("Fragno DB Outbox", () => {
     await cleanup();
   });
 
+  it("only writes outbox entries for schemas that opt in", async () => {
+    const { dialect } = new SQLocalKysely(":memory:");
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new SQLocalDriverConfig(),
+    });
+
+    try {
+      await migrateSchema(adapter, internalSchema, "");
+      await migrateSchema(adapter, alphaSchema, alphaSchema.name);
+      await migrateSchema(adapter, betaSchema, betaSchema.name);
+
+      const alphaDef = defineFragment("alpha-fragment").extend(withDatabase(alphaSchema)).build();
+      const betaDef = defineFragment("beta-fragment").extend(withDatabase(betaSchema)).build();
+
+      const alphaFragment = instantiate(alphaDef)
+        .withConfig({})
+        .withRoutes([])
+        .withOptions({ databaseAdapter: adapter, outbox: { enabled: true } })
+        .build();
+
+      const betaFragment = instantiate(betaDef)
+        .withConfig({})
+        .withRoutes([])
+        .withOptions({ databaseAdapter: adapter })
+        .build();
+
+      await alphaFragment.inContext(async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(alphaSchema).create("alpha_items", { name: "alpha" }),
+          )
+          .execute();
+      });
+
+      await betaFragment.inContext(async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) => forSchema(betaSchema).create("beta_items", { title: "beta" }))
+          .execute();
+      });
+
+      const entries = await listOutbox(getInternalFragment(adapter));
+      const mutationSchemas = entries
+        .map((entry) => superjson.deserialize(entry.payload as SuperJSONResult) as OutboxPayload)
+        .flatMap((payload) => payload.mutations.map((mutation) => mutation.schema));
+
+      expect(mutationSchemas).toContain(alphaSchema.name);
+      expect(mutationSchemas).not.toContain(betaSchema.name);
+    } finally {
+      await adapter.close();
+    }
+  });
+
   describe.each(adapterConfigs)("adapter opt-in (%s)", (adapterConfig) => {
     it("writes outbox rows only when enabled", async () => {
-      const { db, internalFragment, cleanup } = await buildOutboxTest(adapterConfig);
+      const { fragment, internalFragment, cleanup } = await buildOutboxTest(adapterConfig);
 
-      await db.create("users", { email: "disabled@example.com" });
+      await createUser(fragment, "disabled@example.com");
       const disabledEntries = await listOutbox(internalFragment);
       expect(disabledEntries).toHaveLength(0);
       await cleanup();
 
       const {
-        db: enabledDb,
+        fragment: enabledFragment,
         internalFragment: enabledInternal,
         cleanup: enabledCleanup,
       } = await buildOutboxTest({
         ...adapterConfig,
-        outbox: { enabled: true },
+        outboxEnabled: true,
       });
-      await enabledDb.create("users", { email: "enabled@example.com" });
+      await createUser(enabledFragment, "enabled@example.com");
       const enabledEntries = await listOutbox(enabledInternal);
       expect(enabledEntries).toHaveLength(1);
       await enabledCleanup();

package/src/outbox/outbox.ts

@@ -1,7 +1,9 @@
-import type { AnyTable, FragnoId } from "../schema/create";
+import type { MutationOperation } from "../query/unit-of-work/unit-of-work";
+import type { AnySchema, AnyTable, FragnoId } from "../schema/create";
 
 export type OutboxConfig = {
   enabled: boolean;
+  shouldInclude?: (operation: MutationOperation<AnySchema>) => boolean;
 };
 
 export type OutboxVersionstampStrategy =

package/src/query/column-defaults.ts

@@ -1,5 +1,5 @@
-import type { AnyColumn } from "../schema/create";
 import { createId } from "../id";
+import type { AnyColumn } from "../schema/create";
 
 export type RuntimeDefaultContext = {
   now?: () => Date;

package/src/query/condition-builder.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+
 import { column, idColumn, schema } from "../schema/create";
 import { createBuilder, createIndexedBuilder } from "./condition-builder";
 
@@ -101,6 +102,20 @@ describe("ConditionBuilder", () => {
       });
     });
 
+    it("should expose db now helper", () => {
+      const builder = createBuilder(usersTable.columns);
+
+      const now = builder.now();
+      expect(now).toMatchObject({ tag: "db-now" });
+      expect(typeof now.plus).toBe("function");
+      expect(now.plus({ seconds: 1 })).toMatchObject({ tag: "db-now", offsetMs: 1000 });
+      expect(now.plus({ seconds: 1 }).plus({ minutes: 1 })).toMatchObject({
+        tag: "db-now",
+        offsetMs: 61_000,
+      });
+      expect(builder.interval({ minutes: 1 })).toEqual({ tag: "db-interval", ms: 60_000 });
+    });
+
     it("should support boolean columns", () => {
       const postsTable = testSchema.tables.posts;
       const builder = createBuilder(postsTable.columns);

package/src/query/condition-builder.ts

@@ -1,4 +1,5 @@
 import type { AnyColumn, FragnoId, IdColumn } from "../schema/create";
+import { dbInterval, dbNow, type DbInterval, type DbIntervalInput, type DbNow } from "./db-now";
 
 export type ConditionType = "compare" | "and" | "or" | "not";
 
@@ -54,6 +55,8 @@ export type ConditionBuilder<Columns extends Record<string, AnyColumn>> = {
 
   isNull: (a: keyof Columns) => Condition;
   isNotNull: (a: keyof Columns) => Condition;
+  now: () => DbNow;
+  interval: (input: DbIntervalInput) => DbInterval;
 };
 
 // replacement for `like` (Prisma doesn't support `like`)
@@ -117,6 +120,8 @@ export function createBuilder<Columns extends Record<string, AnyColumn>>(
 
   builder.isNull = (a) => builder(a, "is", null);
   builder.isNotNull = (a) => builder(a, "is not", null);
+  builder.now = () => dbNow();
+  builder.interval = (input) => dbInterval(input);
   builder.not = (condition) => {
     if (typeof condition === "boolean") {
       return !condition;
@@ -249,6 +254,8 @@ export function createIndexedBuilder<Columns extends Record<string, AnyColumn>>(
 
   builder.isNull = (a) => builder(a, "is", null);
   builder.isNotNull = (a) => builder(a, "is not", null);
+  builder.now = () => dbNow();
+  builder.interval = (input) => dbInterval(input);
   builder.not = (condition) => {
     if (typeof condition === "boolean") {
       return !condition;