@casekit/orm2 0.0.0-20250322230249

package/build/builders/types.d.ts

@@ -0,0 +1,87 @@
+import { SQLStatement } from "@casekit/sql";
+export type FindBuilder = {
+    table: Table;
+    columns: SelectedColumn[];
+    joins: Join[];
+    where?: SQLStatement | null;
+    orderBy: OrderBy[];
+    limit?: number;
+    offset?: number;
+    lateralBy?: LateralJoin;
+    tableIndex: number;
+    for?: "update" | "no key update" | "share" | "key share";
+};
+export type CountBuilder = {
+    table: Table;
+    joins: Join[];
+    where?: SQLStatement | null;
+    tableIndex: number;
+    for?: "update" | "no key update" | "share" | "key share";
+};
+export type CreateBuilder = {
+    table: Table;
+    columns: string[];
+    values: unknown[][];
+    returning: ReturnedColumn[];
+    onConflict?: ConflictAction;
+};
+export type UpdateBuilder = {
+    table: Table;
+    set: [column: string, value: unknown][];
+    where: SQLStatement | null;
+    returning: ReturnedColumn[];
+};
+export type DeleteBuilder = {
+    table: Table;
+    where: SQLStatement | null;
+    returning: ReturnedColumn[];
+};
+export type Table = {
+    schema: string;
+    name: string;
+    alias: string;
+    model: string;
+};
+export type SelectedColumn = {
+    table: string;
+    name: string;
+    alias: string;
+    path: string[];
+};
+export type Column = {
+    table: string;
+    name: string;
+};
+export type OrderBy = {
+    column: Column;
+    direction: "ASC" | "DESC";
+};
+export type Join = {
+    type: "LEFT" | "INNER";
+    relation: string;
+    table: Table;
+    columns: {
+        from: Column;
+        to: Column;
+    }[];
+    where?: SQLStatement | null;
+    orderBy?: OrderBy[];
+    path: string[];
+};
+export type LateralJoin = {
+    outerAlias: string;
+    innerAlias: string;
+    primaryKeys: {
+        column: string;
+        type: string;
+        values: unknown[];
+    }[];
+};
+export type ConflictAction = {
+    do: "nothing";
+};
+export type ReturnedColumn = {
+    name: string;
+    alias: string;
+    path: string[];
+};

package/build/builders/types.js

@@ -0,0 +1 @@
+export {};

package/build/connection.d.ts

@@ -0,0 +1,31 @@
+import pg, { QueryResultRow } from "pg";
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { SQLStatement } from "@casekit/sql";
+export declare class Connection {
+    protected readonly config: NormalizedConfig;
+    protected client: pg.Client | null;
+    protected pool: pg.Pool | null;
+    protected poolClient: pg.PoolClient | null;
+    protected _open: boolean;
+    get open(): boolean;
+    constructor(config: NormalizedConfig);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    query<T extends QueryResultRow>(sql: SQLStatement): Promise<pg.QueryResult<T>>;
+    startTransaction(): Promise<Transaction>;
+    isTransaction(): boolean;
+}
+export declare class Transaction extends Connection {
+    private readonly conn;
+    private readonly savepoint;
+    private readonly nested;
+    constructor(config: NormalizedConfig, client?: pg.Client | null, pool?: pg.Pool | null, poolClient?: pg.PoolClient | null, nested?: boolean);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    query<T extends QueryResultRow>(sql: SQLStatement): Promise<pg.QueryResult<T>>;
+    startTransaction(): Promise<Transaction>;
+    begin(): Promise<void>;
+    rollback(): Promise<void>;
+    commit(): Promise<void>;
+    isTransaction(): boolean;
+}

package/build/connection.js

@@ -0,0 +1,206 @@
+import pg from "pg";
+import * as uuid from "uuid";
+import { sql } from "@casekit/sql";
+export class Connection {
+    config;
+    client = null;
+    pool = null;
+    poolClient = null;
+    _open = false;
+    get open() {
+        return this._open;
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        if (this.open) {
+            this.config.logger.warn("Tried to connect, but connection is already open");
+            return;
+        }
+        try {
+            if (this.config.pool) {
+                this.pool = new pg.Pool(this.config.connection ?? undefined);
+            }
+            else {
+                this.client = new pg.Client(this.config.connection ?? undefined);
+                await this.client.connect();
+            }
+            this._open = true;
+        }
+        catch (e) {
+            this.config.logger.error("Error connecting to database", e);
+            await this.close();
+            throw e;
+        }
+    }
+    async close() {
+        if (!this.open) {
+            this.config.logger.warn("Tried to close connection, but it is already closed");
+            return;
+        }
+        try {
+            if (this.client) {
+                await this.client.end();
+            }
+            if (this.pool) {
+                await this.pool.end();
+            }
+            /* v8 ignore next 3 */
+        }
+        catch (e) {
+            this.config.logger.error("Error closing client", e);
+            throw e;
+        }
+        finally {
+            this._open = false;
+        }
+    }
+    async query(sql) {
+        try {
+            if (!this.open) {
+                throw new Error("Tried to run query but not connected");
+            }
+            else if (this.poolClient) {
+                return await this.poolClient.query(sql);
+            }
+            else if (this.pool) {
+                return await this.pool.query(sql);
+            }
+            else if (this.client) {
+                return await this.client.query(sql);
+                /* v8 ignore next 3 */
+            }
+            else {
+                throw new Error("Tried to run query but not connected");
+            }
+        }
+        catch (e) {
+            this.config.logger.error("Error running query");
+            throw e;
+        }
+    }
+    async startTransaction() {
+        if (!this.open) {
+            /* v8 ignore next */
+            throw new Error("Tried to start transaction but not connected");
+        }
+        const tx = new Transaction(this.config, this.client, this.pool, this.pool ? await this.pool.connect() : null, false);
+        await tx.begin();
+        return tx;
+    }
+    isTransaction() {
+        return false;
+    }
+}
+export class Transaction extends Connection {
+    conn;
+    savepoint;
+    nested;
+    constructor(config, client = null, pool = null, poolClient = null, nested = false) {
+        /* v8 ignore next 3 */
+        if (!client && !poolClient) {
+            throw new Error("Tried to start transaction but not connected");
+        }
+        super(config);
+        this.conn = (poolClient ?? client);
+        this.client = client;
+        this.pool = pool;
+        this.poolClient = poolClient;
+        this.nested = nested;
+        this.savepoint = uuid.v4();
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async connect() {
+        throw new Error("Cannot connect in transaction - already connected");
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async close() {
+        throw new Error("Cannot close connection while in transaction");
+    }
+    async query(sql) {
+        /* v8 ignore start */
+        if (!this.open) {
+            throw new Error("Tried to run query but transaction is already closed");
+        }
+        /* v8 ignore stop */
+        try {
+            return await super.query(sql);
+        }
+        catch (e) {
+            this.config.logger.error("Rolling back transaction due to error", e);
+            await this.rollback();
+            throw e;
+        }
+    }
+    async startTransaction() {
+        if (!this.open) {
+            throw new Error("Tried to open nested transaction but parent transaction is closed");
+        }
+        const tx = new Transaction(this.config, this.client, this.pool, this.poolClient, true);
+        await tx.begin();
+        return tx;
+    }
+    async begin() {
+        try {
+            await this.conn.query(this.nested
+                ? sql `SAVEPOINT ${sql.ident(this.savepoint)}`
+                : sql `BEGIN`);
+            this._open = true;
+            /* v8 ignore start */
+        }
+        catch (e) {
+            this.config.logger.error("Error starting transaction", e);
+            await this.rollback();
+            throw e;
+        }
+        /* v8 ignore stop */
+    }
+    async rollback() {
+        if (!this.open)
+            return;
+        try {
+            await this.conn.query(this.nested
+                ? sql `ROLLBACK TO SAVEPOINT ${sql.ident(this.savepoint)}`
+                : sql `ROLLBACK`);
+            /* v8 ignore start */
+        }
+        catch (e) {
+            this.config.logger.error("Error rolling back transaction", e);
+            throw e;
+            /* v8 ignore stop */
+        }
+        finally {
+            this._open = false;
+            if (this.poolClient && !this.nested) {
+                this.poolClient.release();
+            }
+        }
+    }
+    async commit() {
+        if (!this.open) {
+            throw new Error("Tried to commit transaction but it is closed");
+        }
+        try {
+            await this.conn.query(this.nested
+                ? sql `RELEASE SAVEPOINT ${sql.ident(this.savepoint)}`
+                : sql `COMMIT`);
+            /* v8 ignore start */
+        }
+        catch (e) {
+            this.config.logger.error("Error committing transaction", e);
+            await this.rollback();
+            throw e;
+            /* v8 ignore stop */
+        }
+        finally {
+            this._open = false;
+            if (this.poolClient && !this.nested) {
+                this.poolClient.release();
+            }
+        }
+    }
+    isTransaction() {
+        return true;
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,10 @@
+export * as op from "./operators.js";
+export { orm, type Orm } from "./orm.js";
+export type { Config, FieldDefinition, ForeignKeyDefinition, ModelDefinition, ModelDefinitions, ModelType, PostgresDataTypes, RelationDefinition, UniqueConstraintDefinition, } from "@casekit/orm2-schema";
+export type { FindParams } from "./types/FindParams.js";
+export type { FindResult } from "./types/FindResult.js";
+export type { IncludeClause } from "./types/IncludeClause.js";
+export type { OrderByClause } from "./types/OrderByClause.js";
+export type { SelectClause } from "./types/SelectClause.js";
+export type { DefaultOperators, WhereClause } from "./types/WhereClause.js";
+export { SQLStatement, sql } from "@casekit/sql";

package/build/index.js

@@ -0,0 +1,5 @@
+/* v8 ignore start */
+export * as op from "./operators.js";
+export { orm } from "./orm.js";
+export { SQLStatement, sql } from "@casekit/sql";
+/* v8 ignore stop */

package/build/operators.d.ts

@@ -0,0 +1,59 @@
+export declare const $and: unique symbol;
+export declare const $eq: unique symbol;
+export declare const $gt: unique symbol;
+export declare const $gte: unique symbol;
+export declare const $ilike: unique symbol;
+export declare const $in: unique symbol;
+export declare const $is: unique symbol;
+export declare const $like: unique symbol;
+export declare const $lt: unique symbol;
+export declare const $lte: unique symbol;
+export declare const $ne: unique symbol;
+export declare const $not: unique symbol;
+export declare const $or: unique symbol;
+export declare const defaultOperators: {
+    readonly [$eq]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$gt]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$gte]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$ilike]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$is]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$like]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$lt]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$lte]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$ne]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$in]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+    readonly [$not]: ({ table, column }: {
+        table: import("@casekit/sql").SQLStatement;
+        column: import("@casekit/sql").SQLStatement;
+    }, v: unknown) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;
+};

package/build/operators.js

@@ -0,0 +1,44 @@
+import { sql } from "@casekit/sql";
+export const $and = Symbol("and");
+export const $eq = Symbol("eq");
+export const $gt = Symbol("gt");
+export const $gte = Symbol("gte");
+export const $ilike = Symbol("ilike");
+export const $in = Symbol("in");
+export const $is = Symbol("is");
+export const $like = Symbol("like");
+export const $lt = Symbol("lt");
+export const $lte = Symbol("lte");
+export const $ne = Symbol("ne");
+export const $not = Symbol("not");
+export const $or = Symbol("or");
+export const defaultOperators = {
+    [$eq]: ({ table, column }, v) => sql `${table}.${column} = ${v}`,
+    [$gt]: ({ table, column }, v) => sql `${table}.${column} > ${v}`,
+    [$gte]: ({ table, column }, v) => sql `${table}.${column} >= ${v}`,
+    [$ilike]: ({ table, column }, v) => sql `${table}.${column} ILIKE ${v}`,
+    [$is]: ({ table, column }, v) => sql `${table}.${column} IS ${v}`,
+    [$like]: ({ table, column }, v) => sql `${table}.${column} LIKE ${v}`,
+    [$lt]: ({ table, column }, v) => sql `${table}.${column} < ${v}`,
+    [$lte]: ({ table, column }, v) => sql `${table}.${column} <= ${v}`,
+    [$ne]: ({ table, column }, v) => sql `${table}.${column} != ${v}`,
+    [$in]: ({ table, column }, v) => {
+        if (!Array.isArray(v))
+            throw new Error("Non-array passed to IN clause");
+        if (v.length === 0)
+            return sql `${table}.${column} IN (NULL)`;
+        return sql `${table}.${column} IN (${v.map(sql.value)})`;
+    },
+    [$not]: ({ table, column }, v) => {
+        switch (v) {
+            case null:
+                return sql `${table}.${column} IS NOT NULL`;
+            case true:
+                return sql `${table}.${column} IS NOT TRUE`;
+            case false:
+                return sql `${table}.${column} IS NOT FALSE`;
+            default:
+                throw new Error("Invalid value passed to $not operator");
+        }
+    },
+};

package/build/orm.count.d.ts

@@ -0,0 +1,14 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
+import { Connection } from "./connection.js";
+import { CountParams } from "./types/CountParams.js";
+/**
+ * Executes a count query against the database.
+ *
+ * @param config The normalized ORM configuration
+ * @param conn The database connection
+ * @param modelName The name of the model to count records for
+ * @param query Parameters for the count query, including where and include clauses
+ * @returns The number of matching records
+ */
+export declare const count: (config: NormalizedConfig, conn: Connection, modelName: string, query: CountParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => Promise<number>;

package/build/orm.count.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { buildCount } from "./builders/buildCount.js";
+import { countToSql } from "./sql/countToSql.js";
+/**
+ * Executes a count query against the database.
+ *
+ * @param config The normalized ORM configuration
+ * @param conn The database connection
+ * @param modelName The name of the model to count records for
+ * @param query Parameters for the count query, including where and include clauses
+ * @returns The number of matching records
+ */
+export const count = async (config, conn, modelName, query) => {
+    const builder = buildCount(config, modelName, query);
+    const statement = countToSql(builder);
+    config.logger.info("Executing count", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const result = await conn.query(statement);
+    return z.coerce.number().parse(result.rows[0]?.["count"] ?? 0);
+};

package/build/orm.createMany.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinitions } from "@casekit/orm2-schema";
+import { Connection } from "./connection.js";
+import { CreateManyParams } from "./types/CreateManyParams.js";
+export declare const createMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: CreateManyParams<ModelDefinitions, string>) => Promise<Record<string, unknown>[] | number>;

package/build/orm.createMany.js

@@ -0,0 +1,26 @@
+import { buildCreate } from "./builders/buildCreate.js";
+import { createToSql } from "./sql/createToSql.js";
+import { rowToObject } from "./util/rowToObject.js";
+export const createMany = async (config, conn, modelName, query) => {
+    if (query.values.length === 0) {
+        return query.returning ? [] : 0;
+    }
+    const builder = buildCreate(config, modelName, query);
+    const statement = createToSql(builder);
+    config.logger.info("Executing createMany", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const tx = await conn.startTransaction();
+    try {
+        const result = await tx.query(statement);
+        await tx.commit();
+        return query.returning
+            ? result.rows.map((row) => rowToObject(row, builder.returning))
+            : (result.rowCount ?? 0);
+    }
+    catch (e) {
+        await tx.rollback();
+        throw e;
+    }
+};

package/build/orm.createOne.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinitions } from "@casekit/orm2-schema";
+import { Connection } from "./connection.js";
+import { CreateOneParams } from "./types/CreateOneParams.js";
+export declare const createOne: (config: NormalizedConfig, conn: Connection, modelName: string, { values, ...query }: CreateOneParams<ModelDefinitions, string>) => Promise<Record<string, unknown> | number | null>;

package/build/orm.createOne.js

@@ -0,0 +1,34 @@
+import { buildCreate } from "./builders/buildCreate.js";
+import { createToSql } from "./sql/createToSql.js";
+import { rowToObject } from "./util/rowToObject.js";
+export const createOne = async (config, conn, modelName, { values, ...query }) => {
+    const builder = buildCreate(config, modelName, {
+        ...query,
+        values: [values],
+    });
+    const statement = createToSql(builder);
+    config.logger.info("Executing createOne", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const tx = await conn.startTransaction();
+    try {
+        const result = await tx.query(statement);
+        if (!result.rowCount && query.onConflict?.do !== "nothing") {
+            throw new Error("createOne failed to create a row");
+        }
+        await tx.commit();
+        if (query.returning) {
+            return result.rowCount === 0
+                ? null
+                : rowToObject(result.rows[0], builder.returning);
+        }
+        else {
+            return result.rowCount;
+        }
+    }
+    catch (e) {
+        await tx.rollback();
+        throw e;
+    }
+};

package/build/orm.d.ts

@@ -0,0 +1,81 @@
+import { QueryResultRow } from "pg";
+import { DeepReadonly } from "ts-essentials";
+import { ZodSchema } from "zod";
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { Config, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
+import { SQLStatement } from "@casekit/sql";
+import type { Conform, Simplify } from "@casekit/toolbox";
+import { Connection, Transaction } from "./connection.js";
+import { CountParams } from "./types/CountParams.js";
+import { CreateManyParams } from "./types/CreateManyParams.js";
+import { CreateManyResult } from "./types/CreateManyResult.js";
+import { CreateOneParams } from "./types/CreateOneParams.js";
+import { CreateOneResult } from "./types/CreateOneResult.js";
+import { DeleteManyResult } from "./types/DeleteManyResult.js";
+import { DeleteOneResult } from "./types/DeleteOneResult.js";
+import { DeleteParams } from "./types/DeleteParams.js";
+import { FindParams } from "./types/FindParams.js";
+import { FindResult } from "./types/FindResult.js";
+import { Middleware } from "./types/Middleware.js";
+import { RestrictModels } from "./types/RestrictModels.js";
+import { UpdateManyResult } from "./types/UpdateManyResult.js";
+import { UpdateOneResult } from "./types/UpdateOneResult.js";
+import { UpdateParams } from "./types/UpdateParams.js";
+export declare const orm: <const C extends Config>(config: C) => Orm<C>;
+export declare class Orm<const C extends Config = Config, const Models extends ModelDefinitions = C["models"], const Operators extends OperatorDefinitions = C["operators"] extends NonNullable<C["operators"]> ? C["operators"] : {
+    where: never;
+}> {
+    readonly config: NormalizedConfig;
+    private readonly _connection;
+    private readonly _middleware;
+    constructor(config: NormalizedConfig, connection?: Connection | Transaction, middleware?: Middleware[]);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    transact<T>(fn: (db: Orm<C>) => Promise<T>, options?: {
+        rollback: boolean;
+    }): Promise<T>;
+    private getNextMiddleware;
+    findOne<const M extends ModelName<Models>, const Q extends FindParams<Models, Operators, M>>(modelName: M, query: Conform<FindParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<FindResult<Models, Operators, M, Q>>>>;
+    findMany<const M extends ModelName<Models>, const Q extends FindParams<Models, Operators, M>>(modelName: M, query: Conform<FindParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<FindResult<Models, Operators, M, Q>>[]>>;
+    count<const M extends ModelName<Models>, const Q extends CountParams<Models, Operators, M>>(modelName: M, query: Conform<CountParams<Models, Operators, M>, Q>): Promise<number>;
+    createOne<const M extends ModelName<Models>, const Q extends CreateOneParams<Models, M>>(modelName: M, query: Conform<CreateOneParams<Models, M>, Q>): Promise<DeepReadonly<Simplify<CreateOneResult<Models, M, Q>>>>;
+    createMany<const M extends ModelName<Models>, const Q extends CreateManyParams<Models, M>>(modelName: M, query: Conform<CreateManyParams<Models, M>, Q>): Promise<DeepReadonly<Simplify<CreateManyResult<Models, M, Q>>>>;
+    updateOne<const M extends ModelName<Models>, const Q extends UpdateParams<Models, Operators, M>>(modelName: M, query: Conform<UpdateParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<UpdateOneResult<Models, Operators, M, Q>>>>;
+    updateMany<const M extends ModelName<Models>, const Q extends UpdateParams<Models, Operators, M>>(modelName: M, query: Conform<UpdateParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<UpdateManyResult<Models, Operators, M, Q>>>>;
+    deleteOne<const M extends ModelName<Models>, const Q extends DeleteParams<Models, Operators, M>>(modelName: M, query: Conform<DeleteParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<DeleteOneResult<Models, Operators, M, Q>>>>;
+    deleteMany<const M extends ModelName<Models>, const Q extends DeleteParams<Models, Operators, M>>(modelName: M, query: Conform<DeleteParams<Models, Operators, M>, Q>): Promise<DeepReadonly<Simplify<DeleteManyResult<Models, Operators, M, Q>>>>;
+    /**
+     * In some parts of your app - e.g. in the non-tenant specific parts of
+     * a multi-tenant app, where you don't want to restrict by tenant_id -
+     * you may want to only make a subset of models available for querying.
+     * This method allows you to do that by creating a restricted copy of
+     * the ORM with access only to the models you specify.
+     */
+    restrict<const Allowed extends [...ModelName<Models>[]]>(allowed: Allowed): Orm<RestrictModels<C, Allowed[number]>>;
+    /** Returns a new ORM instance with middleware applied.
+     * The new ORM instance shares the same connection as
+     * the one it is called on, but the original instance
+     * does not have the middleware applied. This means
+     * this method can be called multiple times to apply
+     * different middleware to different ORM instances.
+     */
+    middleware(middleware: Middleware[]): Orm<C>;
+    /**
+     * await db.query(z.object({ foo: z.string() }))`
+     *     SELECT foo FROM table WHERE foo = ${value}
+     * `;
+     */
+    query<const ResultType extends QueryResultRow = QueryResultRow>(schema: ZodSchema<ResultType>): (fragments: TemplateStringsArray, ...values: unknown[]) => Promise<ResultType[]>;
+    /**
+     * const statement = sql<{ one: number }>`SELECT 1 as one`;
+     * await db.query(statement);
+     */
+    query<const ResultType extends QueryResultRow = QueryResultRow>(statement: SQLStatement<ResultType>): Promise<ResultType[]>;
+    /**
+     * await db.query<{ one: number }>`SELECT 1 as one`;
+     */
+    query<ResultType extends QueryResultRow = QueryResultRow>(fragments: TemplateStringsArray, ...values: unknown[]): Promise<ResultType[]>;
+    private queryWithTemplateLiteral;
+    private queryWithSQLStatement;
+    private queryWithSchema;
+}

package/build/orm.deleteMany.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
+import { Connection } from "./connection.js";
+import { DeleteParams } from "./types/DeleteParams.js";
+export declare const deleteMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;