@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/shared/from-unit-of-work-compiler.ts

@@ -1,14 +1,25 @@
-import type { SimpleQueryInterface, TableToUpdateValues } from "../../query/simple-query-interface";
-import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
+import type { CursorResult } from "../../query/cursor";
+import { dbInterval, dbNow, type DbInterval, type DbIntervalInput } from "../../query/db-now";
+import type {
+  SimpleQueryInterface,
+  TableToUpdateValues,
+  SelectResult,
+  ExtractJoinOut,
+  ExtractSelect,
+  SelectClause,
+} from "../../query/simple-query-interface";
 import type {
   CompiledMutation,
+  FindBuilder,
   UOWCompiler,
   UOWDecoder,
   UOWExecutor,
+  UOWInstrumentation,
   ValidIndexName,
+  UnitOfWorkConfig as BaseUnitOfWorkConfig,
 } from "../../query/unit-of-work/unit-of-work";
 import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
-import type { CursorResult } from "../../query/cursor";
+import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
 import type { CompiledQuery } from "../../sql-driver/sql-driver";
 
 /**
@@ -25,6 +36,7 @@ export interface UnitOfWorkConfig {
    * since those have to be manually executed.
    */
   dryRun?: boolean;
+  instrumentation?: UOWInstrumentation;
 }
 
 /**
@@ -50,7 +62,7 @@ export interface UnitOfWorkFactory {
   /**
    * Optional WeakMap for schema-to-namespace lookups
    */
-  schemaNamespaceMap?: WeakMap<AnySchema, string>;
+  schemaNamespaceMap?: WeakMap<AnySchema, string | null>;
 }
 
 /**
@@ -91,6 +103,14 @@ class UpdateManySpecialBuilder<TTable extends AnyTable> {
     return this;
   }
 
+  now() {
+    return dbNow();
+  }
+
+  interval(input: DbIntervalInput): DbInterval {
+    return dbInterval(input);
+  }
+
   getConfig() {
     return {
       indexName: this.#indexName,
@@ -132,59 +152,140 @@ export function fromUnitOfWorkCompiler<T extends AnySchema>(
 ): SimpleQueryInterface<T, UnitOfWorkConfig> {
   const { compiler, executor, decoder, uowConfig, schemaNamespaceMap } = factory;
 
-  function createUOW(opts: { name?: string; config?: UnitOfWorkConfig }) {
-    const { onQuery, ...restUowConfig } = opts.config ?? {};
+  function normalizeUowConfig(config?: UnitOfWorkConfig): BaseUnitOfWorkConfig | undefined {
+    if (!config) {
+      return undefined;
+    }
+    const { onQuery, ...restUowConfig } = config;
+    return {
+      ...restUowConfig,
+      onQuery: onQuery
+        ? (query) => {
+            // Extract the actual query from CompiledMutation if needed
+            const actualQuery = isCompiledMutation(query) ? query.query : (query as CompiledQuery);
+            onQuery(actualQuery);
+          }
+        : undefined,
+    };
+  }
 
+  function createBaseUow(opts: { name?: string; config?: UnitOfWorkConfig }) {
     return new UnitOfWork(
       compiler,
       executor,
       decoder,
       opts.name,
-      {
-        ...restUowConfig,
-        onQuery: onQuery
-          ? (query) => {
-              // Extract the actual query from CompiledMutation if needed
-              const actualQuery = isCompiledMutation(query)
-                ? query.query
-                : (query as CompiledQuery);
-              onQuery(actualQuery);
-            }
-          : undefined,
-      },
+      normalizeUowConfig(opts.config),
       schemaNamespaceMap,
-    ).forSchema(schema);
+    );
   }
 
-  return {
-    async find(tableName, builderFn) {
-      const uow = createUOW({ config: uowConfig });
+  function createUOW(opts: { name?: string; config?: UnitOfWorkConfig }) {
+    return createBaseUow(opts).forSchema(schema);
+  }
+
+  async function find<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+    tableName: TableName,
+    builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+  ): Promise<
+    SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    >[]
+  >;
+  async function find<TableName extends keyof T["tables"] & string>(
+    tableName: TableName,
+  ): Promise<SelectResult<T["tables"][TableName], {}, true>[]>;
+  async function find<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+    tableName: TableName,
+    builderFn?: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+  ): Promise<
+    SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    >[]
+  > {
+    const uow = createUOW({ config: uowConfig });
+    if (builderFn) {
       uow.find(tableName, builderFn);
-      const [result]: unknown[][] = await uow.executeRetrieve();
-      return result ?? [];
-    },
+    } else {
+      uow.find(tableName);
+    }
+    const [result]: unknown[][] = await uow.executeRetrieve();
+    return (result ?? []) as SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    >[];
+  }
 
-    async findWithCursor(tableName, builderFn) {
-      const uow = createUOW({ config: uowConfig }).findWithCursor(tableName, builderFn);
-      const [result] = await uow.executeRetrieve();
-      // Result from findWithCursor is always a CursorResult - the UOW decoder handles the conversion
-      return result as CursorResult<unknown>;
-    },
+  async function findWithCursor<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+    tableName: TableName,
+    builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+  ): Promise<
+    CursorResult<
+      SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      >
+    >
+  > {
+    const uow = createUOW({ config: uowConfig }).findWithCursor(tableName, builderFn);
+    const [result] = await uow.executeRetrieve();
+    // Result from findWithCursor is always a CursorResult - the UOW decoder handles the conversion
+    return result as CursorResult<
+      SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      >
+    >;
+  }
 
-    async findFirst(tableName, builderFn) {
-      const uow = createUOW({ config: uowConfig });
-      if (builderFn) {
-        uow.find(tableName, (b) => {
-          builderFn(b);
-          return b.pageSize(1);
-        });
-      } else {
-        uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
-      }
-      // executeRetrieve runs an array of `find` operation results, which each return an array of rows
-      const [result]: unknown[][] = await uow.executeRetrieve();
-      return result?.[0] ?? null;
-    },
+  async function findFirst<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+    tableName: TableName,
+    builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+  ): Promise<SelectResult<
+    T["tables"][TableName],
+    ExtractJoinOut<TBuilderResult>,
+    Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+  > | null>;
+  async function findFirst<TableName extends keyof T["tables"] & string>(
+    tableName: TableName,
+  ): Promise<SelectResult<T["tables"][TableName], {}, true> | null>;
+  async function findFirst<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+    tableName: TableName,
+    builderFn?: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+  ): Promise<SelectResult<
+    T["tables"][TableName],
+    ExtractJoinOut<TBuilderResult>,
+    Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+  > | null> {
+    const uow = createUOW({ config: uowConfig });
+    if (builderFn) {
+      uow.find(tableName, (b) => {
+        builderFn(b);
+        return b.pageSize(1);
+      });
+    } else {
+      uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
+    }
+    // executeRetrieve runs an array of `find` operation results, which each return an array of rows
+    const [result]: unknown[][] = await uow.executeRetrieve();
+    return (result?.[0] ?? null) as SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    > | null;
+  }
+
+  const queryEngine: SimpleQueryInterface<T, UnitOfWorkConfig> = {
+    find,
+    findWithCursor,
+    findFirst,
 
     async create(tableName, values) {
       const uow = createUOW({ config: uowConfig });
@@ -271,7 +372,7 @@ export function fromUnitOfWorkCompiler<T extends AnySchema>(
       }
     },
 
-    async delete(tableName, id, builderFn) {
+    async delete(tableName, id, builderFn?) {
       const uow = createUOW({ config: uowConfig });
       uow.delete(tableName, id, builderFn);
       const { success } = await uow.executeMutations();
@@ -311,5 +412,16 @@ export function fromUnitOfWorkCompiler<T extends AnySchema>(
         },
       });
     },
-  } as SimpleQueryInterface<T, UnitOfWorkConfig>;
+
+    createBaseUnitOfWork(name, nestedUowConfig) {
+      return createBaseUow({
+        name,
+        config: {
+          ...uowConfig,
+          ...nestedUowConfig,
+        },
+      });
+    },
+  };
+  return queryEngine;
 }

package/src/adapters/shared/uow-operation-compiler.ts

@@ -1,14 +1,14 @@
-import type { AnyColumn, AnySchema, AnyTable, FragnoId } from "../../schema/create";
+import { createNamingResolver, type NamingResolver } from "../../naming/sql-naming";
 import type { Condition } from "../../query/condition-builder";
+import { Cursor } from "../../query/cursor";
 import type {
   CompiledMutation,
   RetrievalOperation,
   MutationOperation,
   UOWCompiler,
 } from "../../query/unit-of-work/unit-of-work";
-import { Cursor } from "../../query/cursor";
+import type { AnyColumn, AnySchema, AnyTable, FragnoId } from "../../schema/create";
 import type { DriverConfig } from "../generic-sql/driver-config";
-import { createTableNameMapper, type TableNameMapper } from "./table-name-mapper";
 
 /**
  * Options for compiling a find operation with cursor pagination
@@ -55,24 +55,24 @@ export interface CursorConditionResult {
  */
 export abstract class UOWOperationCompiler<TCompiledQuery> {
   #driverConfig: DriverConfig;
-  #mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined;
+  #resolverFactory?: (schema: AnySchema, namespace: string | null) => NamingResolver;
 
   constructor(
     driverConfig: DriverConfig,
-    mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined,
+    resolverFactory?: (schema: AnySchema, namespace: string | null) => NamingResolver,
   ) {
     this.#driverConfig = driverConfig;
-    this.#mapperFactory = mapperFactory;
+    this.#resolverFactory = resolverFactory;
   }
 
   protected get driverConfig(): DriverConfig {
     return this.#driverConfig;
   }
 
-  protected get mapperFactory():
-    | ((namespace: string | undefined) => TableNameMapper | undefined)
+  protected get resolverFactory():
+    | ((schema: AnySchema, namespace: string | null) => NamingResolver)
     | undefined {
-    return this.#mapperFactory;
+    return this.#resolverFactory;
   }
 
   abstract compileCount(
@@ -105,12 +105,18 @@ export abstract class UOWOperationCompiler<TCompiledQuery> {
   /**
    * Get the mapper for a specific operation based on its namespace
    */
-  protected getMapperForOperation(namespace: string | undefined): TableNameMapper | undefined {
-    return this.#mapperFactory
-      ? this.#mapperFactory(namespace)
-      : namespace
-        ? createTableNameMapper(namespace)
-        : undefined;
+  protected getNamingResolver(
+    schema: AnySchema,
+    namespace: string | null | undefined,
+  ): NamingResolver {
+    if (this.#resolverFactory) {
+      return this.#resolverFactory(schema, namespace ?? null);
+    }
+    return createNamingResolver(
+      schema,
+      namespace ?? null,
+      this.#driverConfig.defaultNamingStrategy,
+    );
   }
 
   /**
@@ -154,9 +160,13 @@ export abstract class UOWOperationCompiler<TCompiledQuery> {
   /**
    * Get the physical table name for an operation, applying namespace mapping if needed
    */
-  protected getPhysicalTableName(logicalName: string, namespace: string | undefined): string {
-    const mapper = this.getMapperForOperation(namespace);
-    return mapper ? mapper.toPhysical(logicalName) : logicalName;
+  protected getPhysicalTableName(
+    schema: AnySchema,
+    logicalName: string,
+    namespace: string | undefined,
+  ): string {
+    const resolver = this.getNamingResolver(schema, namespace ?? null);
+    return resolver.getTableName(logicalName);
   }
 }
 

package/src/adapters/sql/index.ts

@@ -0,0 +1,12 @@
+export {
+  SqlAdapter,
+  type SqlAdapterOptions,
+  type UnitOfWorkConfig,
+  type OutboxConfig,
+  sqliteProfiles,
+  sqliteStorageDefault,
+  sqliteStoragePrisma,
+  type SQLiteStorageMode,
+} from "../generic-sql/generic-sql-adapter";
+
+export type { SQLiteProfile } from "../adapters";

package/src/browser/mod.ts

@@ -0,0 +1,64 @@
+import type { migrate as migrateType } from "../mod";
+import type { withDatabase as withDatabaseType } from "../with-database";
+
+export {
+  createHandlerTxBuilder,
+  createServiceTxBuilder,
+  ServiceTxBuilder,
+  HandlerTxBuilder,
+  type TxResult,
+  type ServiceBuilderMutateContext,
+  type HandlerBuilderMutateContext,
+  type BuilderTransformContextWithMutate,
+  type BuilderTransformContextWithoutMutate,
+  type ExtractServiceRetrieveResults,
+  type ExtractServiceFinalResults,
+} from "../query/unit-of-work/execute-unit-of-work";
+
+export {
+  createUnitOfWork,
+  UnitOfWork,
+  TypedUnitOfWork,
+  type IUnitOfWork,
+  type IUnitOfWorkRestricted,
+  type UOWCompiler,
+  type UOWExecutor,
+  type UOWDecoder,
+} from "../query/unit-of-work/unit-of-work";
+
+export {
+  Cursor,
+  decodeCursor,
+  createCursorFromRecord,
+  type CursorData,
+  type CursorResult,
+} from "../query/cursor";
+
+export {
+  dbNow,
+  dbInterval,
+  type DbNow,
+  type DbInterval,
+  type DbIntervalInput,
+} from "../query/db-now";
+
+export const withDatabase: typeof withDatabaseType = () => {
+  throw new Error("withDatabase is not available in browser builds.");
+};
+
+export const migrate: typeof migrateType = async () => {
+  throw new Error("migrate is not available in browser builds.");
+};
+
+export { defineSyncCommands } from "../sync/commands";
+export type {
+  SubmitAppliedResponse,
+  SubmitConflictReason,
+  SubmitConflictResponse,
+  SubmitRequest,
+  SubmitResponse,
+  SyncCommandDefinition,
+  SyncCommandHandler,
+  SyncCommandRegistry,
+  SyncCommandTxFactory,
+} from "../sync/types";

package/src/client.ts

@@ -0,0 +1,19 @@
+export {
+  buildCondition,
+  createBuilder,
+  operators,
+  type Condition,
+  type ConditionBuilder,
+  type ConditionType,
+  type Operator,
+} from "./query/condition-builder";
+
+export {
+  Cursor,
+  createCursorFromRecord,
+  decodeCursor,
+  type CursorData,
+  type CursorResult,
+} from "./query/cursor-client";
+
+export { generateMigrationFromSchema } from "./migration-engine/auto-from-schema";