@rawsql-ts/ztd-cli 0.15.0 → 0.17.0

package/templates/dist/drivers/pg-testkit/src/types.d.ts

@@ -0,0 +1,69 @@
+import type { QueryConfig, QueryResult, QueryResultRow } from 'pg';
+import type { FixtureTableDefinition, MissingFixtureStrategy, SqlFormatterOptions, TableDefinitionModel, TableDefinitionRegistry } from 'rawsql-ts';
+export type { TableDefinitionModel } from 'rawsql-ts';
+import type { TableRowsFixture } from '@rawsql-ts/testkit-core';
+import type { DdlFixtureLoaderOptions } from '@rawsql-ts/testkit-core';
+interface SchemaResolutionOptions {
+    defaultSchema?: string;
+    searchPath?: string[];
+}
+/** Rows-only fixtures authored by pg-testkit consumers. */
+export type PgTableRowsFixture = TableRowsFixture;
+/** Table definitions shared across testkits and derived from DDL. */
+export type PgTableDefinition = TableDefinitionModel;
+/** Snapshot returned after fixture resolution, containing the tables, resolver-generated registry, and the applied fixture names. */
+export interface PgFixtureSnapshot {
+    fixtureTables: FixtureTableDefinition[];
+    tableDefinitions: TableDefinitionRegistry;
+    fixturesApplied: string[];
+}
+/** Resolves fixture overrides and exposes the most recently applied snapshot. */
+export interface PgFixtureProvider {
+    resolve(overrides?: TableRowsFixture[]): PgFixtureSnapshot;
+}
+/** Input accepted by driver query helpers (raw SQL or pg `QueryConfig`). */
+export type PgQueryInput = string | QueryConfig<unknown[]>;
+/** Represents a Postgres client that can execute queries during testing. */
+export interface PgQueryable {
+    query<T extends QueryResultRow = QueryResultRow>(queryTextOrConfig: PgQueryInput, values?: unknown[]): Promise<QueryResult<T>>;
+    end?(): Promise<void> | void;
+    release?(): void;
+}
+/**
+ * Options accepted when creating a PgTestkit client, including the
+ * connection factory and fixture resolution hooks.
+ */
+export interface CreatePgTestkitClientOptions extends SchemaResolutionOptions {
+    connectionFactory: () => PgQueryable | Promise<PgQueryable>;
+    tableDefinitions?: TableDefinitionModel[];
+    tableRows?: TableRowsFixture[];
+    formatterOptions?: SqlFormatterOptions;
+    missingFixtureStrategy?: MissingFixtureStrategy;
+    onExecute?(sql: string, params?: unknown[] | QueryConfig['values'], fixtures?: string[]): void;
+    /** Directories whose SQL files are converted into fixtures automatically. */
+    ddl?: DdlFixtureLoaderOptions;
+}
+/**
+ * Options accepted when wrapping an existing Postgres client, mirroring
+ * creation options but omitting the connection factory.
+ */
+export interface WrapPgClientOptions extends SchemaResolutionOptions {
+    tableDefinitions?: TableDefinitionModel[];
+    tableRows?: TableRowsFixture[];
+    formatterOptions?: SqlFormatterOptions;
+    missingFixtureStrategy?: MissingFixtureStrategy;
+    onExecute?(sql: string, params?: unknown[] | QueryConfig['values'], fixtures?: string[]): void;
+    /** Shared DDL directory configuration used to infer fixtures for wrapped clients. */
+    ddl?: DdlFixtureLoaderOptions;
+}
+/** Extends any Pg client instance with fixture-aware helper methods. */
+export type WrappedPgClient<T> = T & {
+    withFixtures(fixtures: TableRowsFixture[]): WrappedPgClient<T>;
+};
+export interface CreatePgTestkitPoolOptions extends SchemaResolutionOptions {
+    tableDefinitions?: TableDefinitionModel[];
+    tableRows?: TableRowsFixture[];
+    /** DDL paths that should populate the base fixture set for the pool. */
+    ddl?: DdlFixtureLoaderOptions;
+}
+export type { TableRowsFixture } from '@rawsql-ts/testkit-core';

package/templates/dist/drivers/pg-testkit/src/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/templates/dist/drivers/pg-testkit/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../drivers/pg-testkit/src/types.ts"],"names":[],"mappings":""}

package/templates/dist/drivers/pg-testkit/src/utils/fixtureState.d.ts

@@ -0,0 +1,15 @@
+import type { DdlFixtureLoaderOptions, DdlProcessedFixture, TableRowsFixture } from '@rawsql-ts/testkit-core';
+import type { TableDefinitionModel } from 'rawsql-ts';
+import type { TableNameResolver } from '@rawsql-ts/testkit-core';
+export interface FixtureResolutionOptions {
+    tableDefinitions?: TableDefinitionModel[];
+    tableRows?: TableRowsFixture[];
+    ddl?: DdlFixtureLoaderOptions;
+}
+export interface ResolvedFixtureState {
+    ddlFixtures: DdlProcessedFixture[];
+    tableDefinitions: TableDefinitionModel[];
+    tableRows: TableRowsFixture[];
+}
+/** Produces the merged fixture metadata for any pg-testkit entry point. */
+export declare function resolveFixtureState(options: FixtureResolutionOptions, tableNameResolver: TableNameResolver): ResolvedFixtureState;

package/templates/dist/drivers/pg-testkit/src/utils/fixtureState.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFixtureState = resolveFixtureState;
+const testkit_core_1 = require("@rawsql-ts/testkit-core");
+/** Produces the merged fixture metadata for any pg-testkit entry point. */
+function resolveFixtureState(options, tableNameResolver) {
+    var _a, _b, _c, _d, _e;
+    // Load DDL-derived fixtures when directories were supplied so every consumer shares the same resolver rules.
+    const loader = ((_b = (_a = options.ddl) === null || _a === void 0 ? void 0 : _a.directories) === null || _b === void 0 ? void 0 : _b.length)
+        ? new testkit_core_1.DdlFixtureLoader({
+            ...options.ddl,
+            tableNameResolver,
+        })
+        : undefined;
+    const ddlFixtures = (_c = loader === null || loader === void 0 ? void 0 : loader.getFixtures()) !== null && _c !== void 0 ? _c : [];
+    // Combine generated definitions with any explicit metadata the caller provided.
+    const tableDefinitions = [
+        ...ddlFixtures.map((fixture) => fixture.tableDefinition),
+        ...((_d = options.tableDefinitions) !== null && _d !== void 0 ? _d : []),
+    ];
+    // Merge DDL-sourced rows ahead of caller-supplied fixtures so overrides take precedence.
+    const tableRows = [
+        ...ddlFixtures.flatMap((fixture) => fixture.rows && fixture.rows.length
+            ? [{ tableName: fixture.tableDefinition.name, rows: fixture.rows }]
+            : []),
+        ...((_e = options.tableRows) !== null && _e !== void 0 ? _e : []),
+    ];
+    return {
+        ddlFixtures,
+        tableDefinitions,
+        tableRows,
+    };
+}
+//# sourceMappingURL=fixtureState.js.map

package/templates/dist/drivers/pg-testkit/src/utils/fixtureState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtureState.js","sourceRoot":"","sources":["../../../../../../../drivers/pg-testkit/src/utils/fixtureState.ts"],"names":[],"mappings":";;AAkBA,kDAkCC;AAnDD,0DAA2D;AAgB3D,2EAA2E;AAC3E,SAAgB,mBAAmB,CACjC,OAAiC,EACjC,iBAAoC;;IAEpC,6GAA6G;IAC7G,MAAM,MAAM,GAAG,CAAA,MAAA,MAAA,OAAO,CAAC,GAAG,0CAAE,WAAW,0CAAE,MAAM;QAC7C,CAAC,CAAC,IAAI,+BAAgB,CAAC;YACnB,GAAG,OAAO,CAAC,GAAG;YACd,iBAAiB;SAClB,CAAC;QACJ,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,WAAW,GAAG,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,EAAE,mCAAI,EAAE,CAAC;IAEhD,gFAAgF;IAChF,MAAM,gBAAgB,GAAG;QACvB,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,OAA4B,EAAE,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC;QAC7E,GAAG,CAAC,MAAA,OAAO,CAAC,gBAAgB,mCAAI,EAAE,CAAC;KACpC,CAAC;IAEF,yFAAyF;IACzF,MAAM,SAAS,GAAuB;QACpC,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,OAA4B,EAAE,EAAE,CACtD,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM;YACjC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;YACnE,CAAC,CAAC,EAAE,CACP;QACD,GAAG,CAAC,MAAA,OAAO,CAAC,SAAS,mCAAI,EAAE,CAAC;KAC7B,CAAC;IAEF,OAAO;QACL,WAAW;QACX,gBAAgB;QAChB,SAAS;KACV,CAAC;AACJ,CAAC"}

package/templates/dist/drivers/pg-testkit/src/utils/fixtureValidation.d.ts

@@ -0,0 +1,12 @@
+import type { TableDefinitionModel, TableRowsFixture } from '../types';
+import type { TableNameResolver } from '@rawsql-ts/testkit-core';
+/**
+ * Validates fixture rows against table definitions, ensuring every referenced
+ * table and column exists in the configured DDL or explicit definitions.
+ *
+ * @param tableRows - Fixtures to validate; undefined or empty arrays are no-ops.
+ * @param tableDefinitions - Table metadata to validate against.
+ * @param contextLabel - Optional label prefixed to thrown error messages for clarity.
+ * @throws Error when a fixture references a missing table or column.
+ */
+export declare const validateFixtureRowsAgainstTableDefinitions: (tableRows: TableRowsFixture[] | undefined, tableDefinitions: TableDefinitionModel[], contextLabel?: string, tableNameResolver?: TableNameResolver) => void;

package/templates/dist/drivers/pg-testkit/src/utils/fixtureValidation.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFixtureRowsAgainstTableDefinitions = void 0;
+const rawsql_ts_1 = require("rawsql-ts");
+const normalizeColumnName = (value) => value.toLowerCase();
+/**
+ * Validates fixture rows against table definitions, ensuring every referenced
+ * table and column exists in the configured DDL or explicit definitions.
+ *
+ * @param tableRows - Fixtures to validate; undefined or empty arrays are no-ops.
+ * @param tableDefinitions - Table metadata to validate against.
+ * @param contextLabel - Optional label prefixed to thrown error messages for clarity.
+ * @throws Error when a fixture references a missing table or column.
+ */
+const validateFixtureRowsAgainstTableDefinitions = (tableRows, tableDefinitions, contextLabel, tableNameResolver) => {
+    var _a;
+    if (!(tableRows === null || tableRows === void 0 ? void 0 : tableRows.length)) {
+        return;
+    }
+    const prefix = contextLabel ? `${contextLabel}: ` : '';
+    // Build a lookup keyed by resolved table names so definitions can be resolved quickly.
+    const definitionLookup = new Map();
+    for (const definition of tableDefinitions) {
+        const key = (_a = tableNameResolver === null || tableNameResolver === void 0 ? void 0 : tableNameResolver.resolve(definition.name)) !== null && _a !== void 0 ? _a : (0, rawsql_ts_1.normalizeTableName)(definition.name);
+        definitionLookup.set(key, definition);
+    }
+    const columnCache = new Map();
+    for (const fixture of tableRows) {
+        const resolvedTableName = tableNameResolver
+            ? tableNameResolver.resolve(fixture.tableName, (candidate) => definitionLookup.has(candidate))
+            : (0, rawsql_ts_1.normalizeTableName)(fixture.tableName);
+        const tableDefinition = definitionLookup.get(resolvedTableName);
+        if (!tableDefinition) {
+            throw new Error(`${prefix}Table '${fixture.tableName}' is not defined by the configured DDL or explicit table definitions.`);
+        }
+        // Memoize column metadata for each resolved table to avoid repeated work.
+        let columnNames = columnCache.get(resolvedTableName);
+        if (!columnNames) {
+            columnNames = new Set(tableDefinition.columns.map((column) => normalizeColumnName(column.name)));
+            columnCache.set(resolvedTableName, columnNames);
+        }
+        // Validate each row so mistyped columns surface immediately during setup.
+        for (const row of fixture.rows) {
+            for (const column of Object.keys(row)) {
+                if (!columnNames.has(normalizeColumnName(column))) {
+                    throw new Error(`${prefix}Column '${column}' not found in table '${fixture.tableName}'. Please fix the fixture to match the DDL.`);
+                }
+            }
+        }
+    }
+};
+exports.validateFixtureRowsAgainstTableDefinitions = validateFixtureRowsAgainstTableDefinitions;
+//# sourceMappingURL=fixtureValidation.js.map

package/templates/dist/drivers/pg-testkit/src/utils/fixtureValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtureValidation.js","sourceRoot":"","sources":["../../../../../../../drivers/pg-testkit/src/utils/fixtureValidation.ts"],"names":[],"mappings":";;;AAAA,yCAA+C;AAI/C,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;AAE3E;;;;;;;;GAQG;AACI,MAAM,0CAA0C,GAAG,CACxD,SAAyC,EACzC,gBAAwC,EACxC,YAAqB,EACrB,iBAAqC,EAC/B,EAAE;;IACR,IAAI,CAAC,CAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,MAAM,CAAA,EAAE,CAAC;QACvB,OAAO;IACT,CAAC;IAED,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IAEvD,uFAAuF;IACvF,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAgC,CAAC;IACjE,KAAK,MAAM,UAAU,IAAI,gBAAgB,EAAE,CAAC;QAC1C,MAAM,GAAG,GAAG,MAAA,iBAAiB,aAAjB,iBAAiB,uBAAjB,iBAAiB,CAAE,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,mCAAI,IAAA,8BAAkB,EAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC/F,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,GAAG,EAAuB,CAAC;IAEnD,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;QAChC,MAAM,iBAAiB,GAAG,iBAAiB;YACzC,CAAC,CAAC,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC9F,CAAC,CAAC,IAAA,8BAAkB,EAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1C,MAAM,eAAe,GAAG,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CACb,GAAG,MAAM,UAAU,OAAO,CAAC,SAAS,uEAAuE,CAC5G,CAAC;QACJ,CAAC;QAED,0EAA0E;QAC1E,IAAI,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,WAAW,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjG,WAAW,CAAC,GAAG,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC;QAClD,CAAC;QAED,0EAA0E;QAC1E,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YAC/B,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBAClD,MAAM,IAAI,KAAK,CACb,GAAG,MAAM,WAAW,MAAM,yBAAyB,OAAO,CAAC,SAAS,6CAA6C,CAClH,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAlDW,QAAA,0CAA0C,8CAkDrD"}

package/templates/dist/mapper-core/src/index.d.ts

@@ -0,0 +1,160 @@
+/**
+ * A single database row returned by a SQL driver.
+ * Row keys are SQL column names, which must be strings; symbol keys are not supported.
+ */
+export type Row = Record<string, unknown>;
+/**
+ * Executes SQL and returns the resulting rows.
+ *
+ * The mapper keeps this layer DBMS/driver agnostic; callers inject the concrete
+ * executor that speaks to the desired database.
+ */
+export type QueryExecutor = (sql: string, params: unknown[]) => Promise<Row[]>;
+/**
+ * Defines how a column prefix, key, and optional overrides map to an entity.
+ */
+export interface EntityOptions<T, K extends Extract<keyof T, string>> {
+    name: string;
+    key: K;
+    prefix?: string;
+    columnMap?: Partial<Record<Extract<keyof T, string>, string>>;
+    coerce?: boolean;
+    coerceFn?: (value: unknown) => unknown;
+}
+/**
+ * Describes how a child entity references a parent mapping.
+ */
+export interface BelongsToOptions {
+    optional?: boolean;
+}
+/**
+ * Controls how raw column names are normalized for simple mapping.
+ */
+export type KeyTransform = 'snake_to_camel' | 'none' | ((column: string) => string);
+/**
+ * Supported type hints for `mapSimpleRows`, controlling how primitive values are coerced before identifier normalization.
+ */
+export type SimpleMapTypeHint = 'string' | 'number' | 'boolean' | 'date' | 'bigint';
+/**
+ * Options that influence simple (duck-typed) row mapping.
+ */
+export interface SimpleMapOptions {
+    keyTransform?: KeyTransform;
+    idKeysAsString?: boolean;
+    typeHints?: Record<string, SimpleMapTypeHint>;
+    coerceDates?: boolean;
+    coerceFn?: (args: {
+        key: string;
+        sourceKey: string;
+        value: unknown;
+    }) => unknown;
+}
+/**
+ * Named presets for simple mapping that avoid implicit inference.
+ */
+export declare const simpleMapPresets: {
+    safe(): SimpleMapOptions;
+    pgLike(): SimpleMapOptions;
+};
+type ParentLink<T> = {
+    propertyName: string;
+    parent: EntityMapping<any>;
+    localKey: string;
+    optional: boolean;
+};
+type RowContext = {
+    row: Row;
+    normalizedColumns: Map<string, string>;
+};
+/**
+ * Builds an entity mapping that can be consumed by {@link Mapper#query} or {@link mapRows}.
+ */
+export declare class EntityMapping<T, K extends Extract<keyof T, string> = Extract<keyof T, string>> {
+    readonly name: string;
+    readonly key: K;
+    readonly prefix: string;
+    readonly parents: ParentLink<T>[];
+    private readonly columnMap;
+    private readonly overrideLookup;
+    private readonly prefixNormalized;
+    private readonly prefixLength;
+    private readonly shouldCoerce;
+    private readonly coerceFn;
+    constructor(options: EntityOptions<T, K>);
+    /**
+     * Registers a parent relationship that will be attached after the current row is mapped.
+     */
+    belongsTo<P, PK extends Extract<keyof P, string>>(propertyName: Extract<keyof T, string>, parent: EntityMapping<P, PK>, localKey: Extract<keyof T, string>, options?: BelongsToOptions): this;
+    /**
+     * Registers a parent relationship with an explicit local key.
+     */
+    belongsToWithLocalKey<P, PK extends Extract<keyof P, string>>(propertyName: Extract<keyof T, string>, parent: EntityMapping<P, PK>, localKey: Extract<keyof T, string>): this;
+    /**
+     * Registers an optional parent relationship with an explicit local key.
+     */
+    belongsToOptional<P, PK extends Extract<keyof P, string>>(propertyName: Extract<keyof T, string>, parent: EntityMapping<P, PK>, localKey?: Extract<keyof T, string>): this;
+    matchColumn(columnName: string): string | undefined;
+    resolveColumnName(propertyName: string): string;
+    readKeyValue(ctx: RowContext): unknown;
+    assignFields(target: Record<string, unknown>, ctx: RowContext): void;
+    private normalizeColumnValue;
+}
+/**
+ * Creates a new entity mapping from the provided options.
+ */
+export declare function entity<T, K extends Extract<keyof T, string> = Extract<keyof T, string>>(options: EntityOptions<T, K>): EntityMapping<T, K>;
+/**
+ * Builds a column map by prefixing each property with the provided prefix and
+ * converting property names to snake_case.
+ */
+export declare function columnMapFromPrefix<K extends string>(prefix: string, properties: readonly K[]): Record<K, string>;
+/**
+ * Executes SQL via the provided executor and maps the rows using the supplied mapping.
+ */
+export declare class Mapper {
+    private readonly executor;
+    private readonly defaults;
+    constructor(executor: QueryExecutor, defaults?: SimpleMapOptions | undefined);
+    query<T>(sql: string, params: unknown[], mapping: EntityMapping<T>): Promise<T[]>;
+    query<T>(sql: string, params?: unknown[], options?: SimpleMapOptions): Promise<T[]>;
+    queryOne<T>(sql: string, params: unknown[], mapping: EntityMapping<T>): Promise<T | undefined>;
+    queryOne<T>(sql: string, params?: unknown[], options?: SimpleMapOptions): Promise<T | undefined>;
+}
+/**
+ * This package maps rows and does not manage DB drivers.
+ * Inject a query executor rather than wiring connections inside the mapper.
+ */
+export declare function createMapper(executor: QueryExecutor, defaults?: SimpleMapOptions): Mapper;
+/**
+ * Creates a mapper using the supplied executor and user defaults.
+ * This helper is the recommended entry point when wiring an executor because
+ * it clearly signals where defaults are configured.
+ */
+export declare function createMapperFromExecutor(executor: QueryExecutor, defaults?: SimpleMapOptions): Mapper;
+/**
+ * Normalizes an executor returning `{ rows }` so it can be consumed by the mapper.
+ */
+export declare function toRowsExecutor(executorOrTarget: ((sql: string, params: unknown[]) => Promise<{
+    rows: Row[];
+} | {
+    rows: Row[];
+    rowCount?: number;
+} | Row[]>) | {
+    [key: string]: (...args: unknown[]) => Promise<unknown>;
+}, methodName?: string): QueryExecutor;
+/**
+ * Maps a pre-fetched row array into typed objects defined by an entity mapping.
+ * Row values remain `unknown`, and the mapper only applies the general-purpose
+ * coercion rules declared in `coerceColumnValue`.
+ */
+export declare function mapRows<T>(rows: Row[], mapping: EntityMapping<T>): T[];
+/**
+ * Maps pre-fetched rows into typed DTOs using the simple map preset, honoring key transforms, type hints, and optional coercion settings.
+ *
+ * @template T Target DTO shape.
+ * @param rows Rows produced by the SQL executor.
+ * @param options Optional overrides that control key normalization, coercion, and type hints.
+ * @returns An array of `T` instances synthesized from `rows`.
+ */
+export declare function mapSimpleRows<T>(rows: Row[], options?: SimpleMapOptions): T[];
+export {};