@mateusseiboth/ember-orm 0.1.0

package/dist/index-BSXZjDUd.d.ts

@@ -0,0 +1,459 @@
+import { S as SchemaDocument, M as ModelNode } from './index-D0xIdtCl.js';
+
+/**
+ * Database driver abstraction. The query engine depends only on these
+ * interfaces (DIP), never on `node-firebird` directly, so a different
+ * backend could be plugged in without touching the engine.
+ */
+interface ConnectionConfig {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    role?: string;
+    encoding?: string;
+    pageSize?: number;
+    /** Max pooled connections. */
+    poolMax?: number;
+    blobAsText?: boolean;
+    lowercaseKeys?: boolean;
+    /**
+     * Authentication plugin. Firebird 3+ defaults to "Srp" (secure remote
+     * password) and is negotiated automatically; use "Legacy_Auth" for legacy
+     * Firebird 2.1/2.5 servers.
+     */
+    authPlugin?: "Srp" | "Legacy_Auth";
+    /** Enable wire compression (Firebird 3+). */
+    wireCompression?: boolean;
+    /**
+     * Target server major version, used to pick version-specific SQL/DDL
+     * (e.g. BOOLEAN vs SMALLINT, IDENTITY vs generator+trigger). Defaults to 3.
+     */
+    version?: FirebirdVersion;
+}
+type FirebirdVersion = "2.1" | "2.5" | "3" | "4" | "5";
+type SqlValue = string | number | boolean | bigint | Date | Buffer | null;
+/** A connection scoped to an open transaction. */
+interface TransactionContext {
+    /** Run a parameterized query and return all rows. */
+    query<T = Record<string, unknown>>(sql: string, params?: readonly SqlValue[]): Promise<T[]>;
+}
+type IsolationLevel = "READ_COMMITTED" | "READ_COMMITTED_READ_ONLY" | "REPEATABLE_READ" | "SERIALIZABLE";
+/** Emitted once per executed statement when a logger is configured. */
+interface QueryEvent {
+    sql: string;
+    params: readonly SqlValue[];
+    durationMs: number;
+    /** Number of rows returned (selects) or affected-ish (best-effort). */
+    rowCount: number;
+}
+type QueryLogger = (event: QueryEvent) => void;
+interface DriverOptions {
+    /** Called after each statement completes (used by the client `log` option). */
+    onQuery?: QueryLogger;
+}
+interface TransactionOptions {
+    isolation?: IsolationLevel;
+}
+/**
+ * The driver contract used by the runtime. Every read and write goes through
+ * `transaction()` so the project rule "every operation runs in a transaction"
+ * holds by construction.
+ */
+interface SqlDriver {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Run `fn` inside a transaction, committing on success and rolling back on
+     * any thrown error. Nested calls reuse the active transaction.
+     */
+    transaction<T>(fn: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+
+/**
+ * Strategy interface for SQL generation. Encapsulates every dialect-specific
+ * decision so the query compiler stays backend-agnostic. Only FirebirdDialect
+ * is implemented today, but the engine never assumes Firebird directly.
+ */
+interface SqlDialect {
+    /** Quote an identifier (table/column/alias). */
+    quoteId(name: string): string;
+    /** Quote a `table.column` reference. */
+    quoteRef(table: string, column: string): string;
+    /** Pagination clause placed right after SELECT (e.g. `FIRST 10 SKIP 5`). */
+    paginationClause(take?: number, skip?: number): string;
+    /** Wrap a value for LIKE with case-insensitive mode. */
+    caseInsensitive(expr: string): string;
+    /** Map a default function name (now/uuid/...) to a SQL expression, if any. */
+    defaultFunctionSql(name: string): string | null;
+    /** Coerce a JS value into a driver-bindable SqlValue. */
+    coerceValue(value: unknown): SqlValue;
+    /** True if the dialect can paginate (controls FIRST/SKIP usage). */
+    readonly supportsReturning: boolean;
+    /** Native BOOLEAN type (Firebird 3+) vs SMALLINT fallback (2.1/2.5). */
+    readonly supportsBooleanType: boolean;
+    /** IDENTITY columns (Firebird 3+) vs generator+trigger (2.1/2.5). */
+    readonly supportsIdentity: boolean;
+    /** Window functions like ROW_NUMBER() OVER (...) (Firebird 3+). */
+    readonly supportsWindowFunctions: boolean;
+    /** DDL type used for boolean columns. */
+    booleanColumnType(): string;
+}
+/**
+ * Firebird 3+/4+ dialect.
+ * - Identifiers are double-quoted to preserve case (introspection yields
+ *   UPPER-CASE names and quoting avoids accidental folding).
+ * - Pagination uses `FIRST n SKIP m` after the SELECT keyword.
+ * - Case-insensitive matching uses UPPER() on both sides.
+ */
+interface FirebirdDialectOptions {
+    version?: FirebirdVersion;
+}
+declare class FirebirdDialect implements SqlDialect {
+    readonly supportsReturning = true;
+    readonly version: FirebirdVersion;
+    readonly supportsBooleanType: boolean;
+    readonly supportsIdentity: boolean;
+    readonly supportsWindowFunctions: boolean;
+    constructor(options?: FirebirdDialectOptions);
+    booleanColumnType(): string;
+    quoteId(name: string): string;
+    quoteRef(table: string, column: string): string;
+    paginationClause(take?: number, skip?: number): string;
+    caseInsensitive(expr: string): string;
+    defaultFunctionSql(name: string): string | null;
+    coerceValue(value: unknown): SqlValue;
+}
+
+/**
+ * Runtime-facing query argument shapes. The generated client produces strict,
+ * per-model versions of these; at runtime the engine works with these generic
+ * forms. Mirrors Prisma's query API surface.
+ */
+type SortOrder = "asc" | "desc";
+type QueryMode = "default" | "insensitive";
+/** Scalar field filter, e.g. `{ equals, in, lt, contains, ... }`. */
+interface ScalarFilter {
+    equals?: unknown;
+    not?: unknown | ScalarFilter;
+    in?: unknown[];
+    notIn?: unknown[];
+    lt?: unknown;
+    lte?: unknown;
+    gt?: unknown;
+    gte?: unknown;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    mode?: QueryMode;
+}
+/** Relation filter for to-one (`is`/`isNot`) and to-many (`some`/`every`/`none`). */
+interface RelationFilter {
+    is?: WhereInput | null;
+    isNot?: WhereInput | null;
+    some?: WhereInput;
+    every?: WhereInput;
+    none?: WhereInput;
+}
+interface WhereInput {
+    AND?: WhereInput | WhereInput[];
+    OR?: WhereInput[];
+    NOT?: WhereInput | WhereInput[];
+    [field: string]: unknown | ScalarFilter | RelationFilter | WhereInput | WhereInput[] | undefined;
+}
+type OrderByInput = Record<string, SortOrder> | Record<string, SortOrder>[];
+type SelectInput = Record<string, boolean | NestedReadArgs>;
+type IncludeInput = Record<string, boolean | NestedReadArgs>;
+/** Fields to exclude from the result (inverse of select). */
+type OmitInput = Record<string, boolean>;
+interface NestedReadArgs {
+    select?: SelectInput;
+    include?: IncludeInput;
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    take?: number;
+    skip?: number;
+    distinct?: string[];
+}
+interface FindManyArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+    take?: number;
+    skip?: number;
+    cursor?: Record<string, unknown>;
+    distinct?: string[];
+}
+interface FindUniqueArgs {
+    where: WhereInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface FindFirstArgs extends FindManyArgs {
+}
+interface CreateArgs {
+    data: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface CreateManyArgs {
+    data: Record<string, unknown>[];
+    skipDuplicates?: boolean;
+}
+interface CreateManyAndReturnArgs {
+    data: Record<string, unknown>[];
+    select?: SelectInput;
+    omit?: OmitInput;
+    skipDuplicates?: boolean;
+}
+interface UpdateArgs {
+    where: WhereInput;
+    data: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface UpdateManyArgs {
+    where?: WhereInput;
+    data: Record<string, unknown>;
+}
+interface UpsertArgs {
+    where: WhereInput;
+    create: Record<string, unknown>;
+    update: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface DeleteArgs {
+    where: WhereInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface DeleteManyArgs {
+    where?: WhereInput;
+}
+interface CountArgs {
+    where?: WhereInput;
+    take?: number;
+    skip?: number;
+    select?: Record<string, boolean> | true;
+}
+interface AggregateArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    take?: number;
+    skip?: number;
+    _count?: Record<string, boolean> | true;
+    _avg?: Record<string, boolean>;
+    _sum?: Record<string, boolean>;
+    _min?: Record<string, boolean>;
+    _max?: Record<string, boolean>;
+}
+interface GroupByArgs extends AggregateArgs {
+    by: string[];
+    having?: WhereInput;
+}
+
+/**
+ * The query engine executes high-level operations against a driver. Reads use
+ * a projection + relation-stitching pipeline (relations are loaded with
+ * separate batched queries, Prisma-style). Writes are delegated to
+ * WriteProcessor. Every operation runs inside a driver transaction.
+ */
+declare class QueryEngine {
+    private readonly schema;
+    private readonly dialect;
+    private readonly driver;
+    constructor(schema: SchemaDocument, dialect: SqlDialect, driver: SqlDriver);
+    model(name: string): ModelNode;
+    private run;
+    private execOn;
+    findMany(name: string, args?: FindManyArgs): Promise<Record<string, unknown>[]>;
+    findFirst(name: string, args?: FindFirstArgs): Promise<Record<string, unknown> | null>;
+    findFirstOrThrow(name: string, args?: FindFirstArgs): Promise<Record<string, unknown>>;
+    findUnique(name: string, args: FindUniqueArgs): Promise<Record<string, unknown> | null>;
+    findUniqueOrThrow(name: string, args: FindUniqueArgs): Promise<Record<string, unknown>>;
+    count(name: string, args?: CountArgs): Promise<number>;
+    aggregate(name: string, args?: AggregateArgs): Promise<Record<string, unknown>>;
+    groupBy(name: string, args: GroupByArgs): Promise<Record<string, unknown>[]>;
+    create(name: string, args: CreateArgs): Promise<Record<string, unknown>>;
+    createMany(name: string, args: CreateManyArgs): Promise<{
+        count: number;
+    }>;
+    /** Like createMany, but returns the created records (no nested relations). */
+    createManyAndReturn(name: string, args: CreateManyAndReturnArgs): Promise<Record<string, unknown>[]>;
+    update(name: string, args: UpdateArgs): Promise<Record<string, unknown>>;
+    updateMany(name: string, args: UpdateManyArgs): Promise<{
+        count: number;
+    }>;
+    upsert(name: string, args: UpsertArgs): Promise<Record<string, unknown>>;
+    delete(name: string, args: DeleteArgs): Promise<Record<string, unknown>>;
+    deleteMany(name: string, args?: DeleteManyArgs): Promise<{
+        count: number;
+    }>;
+    private readMany;
+    private loadRelation;
+    private readRelations;
+    /**
+     * Resolve which to-many relations to count for `_count` in select/include.
+     * `_count: true` counts every list relation; `_count: { select: { rel } }`
+     * counts the named ones.
+     */
+    private readCountRelations;
+    /** Attach a `_count` object to each row with per-relation child counts. */
+    private loadCounts;
+    private readBack;
+    private readBackOne;
+    private requireOne;
+    private findOneRaw;
+    private countMatching;
+    private pickKeys;
+    private assertUniqueWhere;
+}
+
+/**
+ * The full set of operations exposed on `client.<model>`. The generated client
+ * narrows every argument and return type per model; this is the untyped runtime
+ * surface they share.
+ */
+interface ModelDelegate {
+    findMany(args?: FindManyArgs): Promise<Record<string, unknown>[]>;
+    findFirst(args?: FindFirstArgs): Promise<Record<string, unknown> | null>;
+    findFirstOrThrow(args?: FindFirstArgs): Promise<Record<string, unknown>>;
+    findUnique(args: FindUniqueArgs): Promise<Record<string, unknown> | null>;
+    findUniqueOrThrow(args: FindUniqueArgs): Promise<Record<string, unknown>>;
+    create(args: CreateArgs): Promise<Record<string, unknown>>;
+    createMany(args: CreateManyArgs): Promise<{
+        count: number;
+    }>;
+    createManyAndReturn(args: CreateManyAndReturnArgs): Promise<Record<string, unknown>[]>;
+    update(args: UpdateArgs): Promise<Record<string, unknown>>;
+    updateMany(args: UpdateManyArgs): Promise<{
+        count: number;
+    }>;
+    upsert(args: UpsertArgs): Promise<Record<string, unknown>>;
+    delete(args: DeleteArgs): Promise<Record<string, unknown>>;
+    deleteMany(args?: DeleteManyArgs): Promise<{
+        count: number;
+    }>;
+    count(args?: CountArgs): Promise<number>;
+    aggregate(args?: AggregateArgs): Promise<Record<string, unknown>>;
+    groupBy(args: GroupByArgs): Promise<Record<string, unknown>[]>;
+}
+
+/**
+ * Client Extensions ($extends), middleware ($use) and the fluent API live here.
+ * The delegate factory composes per-operation query hooks, computes `result`
+ * fields, and returns fluent thenables for single-record reads.
+ */
+interface ResultFieldExtension {
+    needs?: Record<string, boolean>;
+    compute: (record: Record<string, unknown>) => unknown;
+}
+interface QueryHookParams {
+    model: string;
+    operation: string;
+    args: Record<string, unknown>;
+    query: (args: Record<string, unknown>) => Promise<unknown>;
+}
+type QueryHook = (params: QueryHookParams) => Promise<unknown>;
+type HookMap = Record<string, QueryHook>;
+interface EmberExtensionArgs {
+    name?: string;
+    result?: Record<string, Record<string, ResultFieldExtension>>;
+    model?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
+    query?: Record<string, HookMap>;
+    client?: Record<string, unknown>;
+}
+/** Prisma-style middleware: `(params, next) => next(params)`. */
+type Middleware = (params: {
+    model?: string;
+    action: string;
+    args: unknown;
+}, next: (params: {
+    model?: string;
+    action: string;
+    args: unknown;
+}) => Promise<unknown>) => Promise<unknown>;
+
+interface ClientOptions {
+    /** Connection URL or explicit config. Overrides the schema datasource. */
+    datasourceUrl?: string;
+    datasource?: ConnectionConfig;
+    /** A pre-parsed schema document (the generated client passes its own). */
+    schema: SchemaDocument;
+    /**
+     * Query logging: `true` logs each statement to the console; pass a function
+     * to receive structured `QueryEvent`s (sql, params, durationMs, rowCount).
+     */
+    log?: boolean | QueryLogger;
+}
+/**
+ * Runtime client. Builds one delegate per model from the schema and exposes
+ * Prisma-style lifecycle and transaction helpers. The generated client extends
+ * this and adds strongly-typed delegate properties.
+ */
+declare class EmberClientBase {
+    protected readonly driver: SqlDriver;
+    protected readonly engine: QueryEngine;
+    protected readonly dialect: SqlDialect;
+    protected readonly schema: SchemaDocument;
+    private connected;
+    /** Mutated by $extends (per instance) and $use (shared). */
+    protected extensions: EmberExtensionArgs[];
+    protected middlewares: Middleware[];
+    private readonly queryListeners;
+    private readonly baseLog?;
+    /** Dynamic model delegates, keyed by camelCased model name. */
+    [delegate: string]: unknown;
+    constructor(options: ClientOptions);
+    private dispatchQuery;
+    private delegateContext;
+    /** (Re)define one delegate property per model using the current extensions. */
+    private installDelegates;
+    /**
+     * Prisma-style Client Extensions. Returns a new client (the original is
+     * unchanged) that shares the connection/engine but applies the extension's
+     * `result` / `model` / `query` / `client` definitions.
+     */
+    $extends(extension: EmberExtensionArgs): this;
+    /** Prisma-style middleware: runs around every operation. */
+    $use(middleware: Middleware): void;
+    /** Subscribe to query events (mirrors the `log` callback). */
+    $on(event: "query", listener: QueryLogger): void;
+    /** Type-safe access to a delegate by model name. */
+    model(name: string): ModelDelegate;
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+    /**
+     * Run work inside a single transaction.
+     * - Interactive form: `$transaction(async (tx) => { ... })`.
+     * - Sequential form: `$transaction([(tx) => tx.user.create(...), ...])`.
+     *
+     * Because the driver tracks the active transaction via AsyncLocalStorage,
+     * every delegate call made on the passed client runs in the same transaction.
+     */
+    $transaction<T>(fn: (tx: this) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    $transaction<T>(thunks: ((tx: this) => Promise<T>)[], options?: TransactionOptions): Promise<T[]>;
+    /** Execute a raw read query (returns rows) inside a transaction. */
+    $queryRawUnsafe<T = Record<string, unknown>>(sql: string, ...params: unknown[]): Promise<T[]>;
+    /** Execute a raw write statement inside a transaction; returns affected rows when available. */
+    $executeRawUnsafe(sql: string, ...params: unknown[]): Promise<number>;
+    /** Tagged-template raw query: `client.$queryRaw\`SELECT * FROM T WHERE id = ${id}\``. */
+    $queryRaw<T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
+    $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
+}
+/**
+ * Factory for an untyped client when you don't use the generated client.
+ * Prefer the generated `EmberClient` for full type-safety.
+ */
+declare function createClient(options: ClientOptions): EmberClientBase;
+
+export { type AggregateArgs as A, type ConnectionConfig as C, type DriverOptions as D, EmberClientBase as E, type FindManyArgs as F, type GroupByArgs as G, type IncludeInput as I, type ModelDelegate as M, type OrderByInput as O, QueryEngine as Q, type ResultFieldExtension as R, type SqlDriver as S, type TransactionContext as T, type UpdateArgs as U, type WhereInput as W, type TransactionOptions as a, type SqlValue as b, type SqlDialect as c, type ClientOptions as d, type CreateArgs as e, type DeleteArgs as f, type FindUniqueArgs as g, FirebirdDialect as h, type IsolationLevel as i, type SelectInput as j, type UpsertArgs as k, createClient as l, type EmberExtensionArgs as m, type Middleware as n, type QueryEvent as o, type QueryHook as p, type QueryHookParams as q, type QueryLogger as r };