@edium/halifax 2.1.0 → 2.2.0

package/dist/adapters/orm/drizzle/DrizzleAdapter.d.ts

@@ -0,0 +1,128 @@
+import type { AnyColumn, SQL, Table } from 'drizzle-orm';
+import type { IQueryOptions } from '@edium/halifax-types';
+import type { Repository, FieldDefinition, ListOptions, ListResult, QueryResult, UpdateManyResult, DeleteManyResult, TenantScope } from '../../../core/types.js';
+type DrizzleOrderByArg = SQL | AnyColumn | ((aliases: Record<string, AnyColumn>) => unknown);
+/**
+ * A dynamic Drizzle SELECT chain (returned after calling `.$dynamic()`).
+ * All methods remain on the type regardless of call order.
+ */
+interface DrizzleDynamicSelect extends PromiseLike<unknown[]> {
+    where(cond?: SQL): DrizzleDynamicSelect;
+    orderBy(...cols: DrizzleOrderByArg[]): DrizzleDynamicSelect;
+    limit(n: number): DrizzleDynamicSelect;
+    offset(n: number): DrizzleDynamicSelect;
+}
+/** The builder returned from `.from()` before dynamic mode is activated. */
+interface DrizzleSelectBuilder extends PromiseLike<unknown[]> {
+    $dynamic(): DrizzleDynamicSelect;
+    where(cond?: SQL): PromiseLike<unknown[]>;
+}
+interface DrizzleFromChain {
+    from(table: Table): DrizzleSelectBuilder;
+}
+interface DrizzleUpdateWhereChain {
+    returning(): Promise<unknown[]>;
+}
+interface DrizzleUpdateSetChain {
+    where(cond?: SQL): DrizzleUpdateWhereChain;
+}
+interface DrizzleUpdateChain {
+    set(data: Record<string, unknown>): DrizzleUpdateSetChain;
+}
+interface DrizzleDeleteWhereChain {
+    returning(): Promise<unknown[]>;
+}
+interface DrizzleDeleteChain {
+    where(cond?: SQL): DrizzleDeleteWhereChain;
+}
+interface DrizzleInsertValuesChain {
+    returning(): Promise<unknown[]>;
+}
+interface DrizzleInsertChain {
+    values(data: unknown): DrizzleInsertValuesChain;
+}
+export interface AnyDrizzleDB {
+    select(fields?: Record<string, AnyColumn | SQL>): DrizzleFromChain;
+    insert(table: Table): DrizzleInsertChain;
+    update(table: Table): DrizzleUpdateChain;
+    delete(table: Table): DrizzleDeleteChain;
+}
+export interface DrizzleAdapterConfig {
+    /**
+     * Primary-key field name. Defaults to auto-detecting the first column with `.primaryKey()`.
+     * Set explicitly when using composite PKs or a non-standard naming convention.
+     */
+    idField?: string;
+}
+/**
+ * Drizzle ORM repository adapter for `@edium/halifax`.
+ *
+ * Install `drizzle-orm` as a peer dependency alongside your preferred Drizzle driver
+ * (`drizzle-orm/better-sqlite3`, `drizzle-orm/postgres-js`, `drizzle-orm/mysql2`, etc.)
+ * then pass the `db` instance and your table schema:
+ *
+ * ```ts
+ * import { DrizzleAdapter } from '@edium/halifax/drizzle'
+ * import { drizzle } from 'drizzle-orm/postgres-js'
+ * import postgres from 'postgres'
+ * import { usersTable } from './schema'
+ *
+ * const db = drizzle(postgres(process.env.DATABASE_URL!))
+ *
+ * const usersResource: ResourceDefinition = {
+ *   routePrefix: 'users',
+ *   repository: new DrizzleAdapter(db, usersTable),
+ * }
+ * ```
+ *
+ * Field schema and types are inferred automatically from the Drizzle table definition.
+ * Multi-tenant isolation via `withScope()` and the advanced query builder via
+ * `executeQuery()` are both supported.
+ *
+ * @template TRecord - Shape of the records returned from the database.
+ * @template TCreate - Shape of the data used for inserts (defaults to `Partial<TRecord>`).
+ * @template TUpdate - Shape of the data used for updates (defaults to `Partial<TRecord>`).
+ */
+export declare class DrizzleAdapter<TRecord = Record<string, unknown>, TCreate = Partial<TRecord>, TUpdate = Partial<TRecord>> implements Repository<TRecord, TCreate, TUpdate> {
+    private readonly db;
+    private readonly table;
+    readonly fields: FieldDefinition[];
+    readonly idField: string;
+    private readonly columns;
+    private readonly scope;
+    constructor(db: AnyDrizzleDB, table: Table, config?: DrizzleAdapterConfig, scope?: TenantScope | null);
+    private detectPrimaryKey;
+    /**
+     * Derives a Halifax field schema from a Drizzle table definition.
+     * Column types are mapped to their OpenAPI equivalents automatically.
+     * @param table - The Drizzle table schema.
+     * @param idField - The primary-key field name (auto-detected when omitted).
+     * @returns The resolved field definition list.
+     */
+    static fieldsFromTable(table: Table, idField?: string): FieldDefinition[];
+    /**
+     * Returns a dynamic SELECT builder so the chain type stays stable across `.where()`,
+     * `.orderBy()`, `.limit()`, and `.offset()` calls — Drizzle's `.$dynamic()` opts out
+     * of the progressive-omit type narrowing.
+     */
+    private buildSelect;
+    private listWhereToSQL;
+    private withScopeWhere;
+    private stripScope;
+    getOne(id: string | number, options?: Pick<ListOptions, 'fields' | 'include'>): Promise<TRecord | null>;
+    getMany(options?: ListOptions): Promise<ListResult<TRecord>>;
+    createOne(data: TCreate, _options?: {
+        idempotencyKey?: string;
+    }): Promise<TRecord>;
+    createMany(data: TCreate[], _options?: {
+        idempotencyKey?: string;
+    }): Promise<TRecord[]>;
+    updateOne(id: string | number, data: TUpdate): Promise<TRecord | null>;
+    upsertOne(id: string | number, data: TCreate & TUpdate): Promise<TRecord>;
+    updateMany(query: IQueryOptions, data: TUpdate): Promise<UpdateManyResult<TRecord>>;
+    deleteOne(id: string | number): Promise<boolean>;
+    deleteMany(query: IQueryOptions): Promise<DeleteManyResult>;
+    executeQuery(query: IQueryOptions): Promise<QueryResult<TRecord>>;
+    withScope(scope: TenantScope): Repository<TRecord, TCreate, TUpdate>;
+}
+export {};

package/dist/adapters/orm/drizzle/DrizzleAdapter.js

@@ -0,0 +1,255 @@
+import { count, eq, getTableColumns, and, inArray, asc, desc } from 'drizzle-orm';
+import { astToDrizzleWhere, astToDrizzleOrderBy } from './astToDrizzle.js';
+function drizzleTypeToOpenApi(col) {
+    switch (col.dataType) {
+        case 'string':
+            return { type: 'string' };
+        case 'number':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'bigint':
+            return { type: 'integer', format: 'int64' };
+        case 'date':
+            return { type: 'string', format: 'date-time' };
+        case 'json':
+            return { type: 'object' };
+        case 'buffer':
+            return { type: 'string', format: 'binary' };
+        default:
+            return {};
+    }
+}
+/**
+ * Drizzle ORM repository adapter for `@edium/halifax`.
+ *
+ * Install `drizzle-orm` as a peer dependency alongside your preferred Drizzle driver
+ * (`drizzle-orm/better-sqlite3`, `drizzle-orm/postgres-js`, `drizzle-orm/mysql2`, etc.)
+ * then pass the `db` instance and your table schema:
+ *
+ * ```ts
+ * import { DrizzleAdapter } from '@edium/halifax/drizzle'
+ * import { drizzle } from 'drizzle-orm/postgres-js'
+ * import postgres from 'postgres'
+ * import { usersTable } from './schema'
+ *
+ * const db = drizzle(postgres(process.env.DATABASE_URL!))
+ *
+ * const usersResource: ResourceDefinition = {
+ *   routePrefix: 'users',
+ *   repository: new DrizzleAdapter(db, usersTable),
+ * }
+ * ```
+ *
+ * Field schema and types are inferred automatically from the Drizzle table definition.
+ * Multi-tenant isolation via `withScope()` and the advanced query builder via
+ * `executeQuery()` are both supported.
+ *
+ * @template TRecord - Shape of the records returned from the database.
+ * @template TCreate - Shape of the data used for inserts (defaults to `Partial<TRecord>`).
+ * @template TUpdate - Shape of the data used for updates (defaults to `Partial<TRecord>`).
+ */
+export class DrizzleAdapter {
+    db;
+    table;
+    fields;
+    idField;
+    columns;
+    scope;
+    constructor(db, table, config = {}, scope = null) {
+        this.db = db;
+        this.table = table;
+        this.columns = getTableColumns(table);
+        this.idField = config.idField ?? this.detectPrimaryKey();
+        this.fields = DrizzleAdapter.fieldsFromTable(table, this.idField);
+        this.scope = scope;
+    }
+    detectPrimaryKey() {
+        for (const [name, col] of Object.entries(this.columns)) {
+            if (col.primary)
+                return name;
+        }
+        return 'id';
+    }
+    /**
+     * Derives a Halifax field schema from a Drizzle table definition.
+     * Column types are mapped to their OpenAPI equivalents automatically.
+     * @param table - The Drizzle table schema.
+     * @param idField - The primary-key field name (auto-detected when omitted).
+     * @returns The resolved field definition list.
+     */
+    static fieldsFromTable(table, idField) {
+        const cols = getTableColumns(table);
+        const pkField = idField ??
+            Object.entries(cols).find(([, c]) => c.primary)?.[0] ??
+            'id';
+        return Object.entries(cols).map(([name, col]) => ({
+            name,
+            filterable: true,
+            sortable: true,
+            selectable: true,
+            writable: name !== pkField,
+            ...drizzleTypeToOpenApi(col)
+        }));
+    }
+    /**
+     * Returns a dynamic SELECT builder so the chain type stays stable across `.where()`,
+     * `.orderBy()`, `.limit()`, and `.offset()` calls — Drizzle's `.$dynamic()` opts out
+     * of the progressive-omit type narrowing.
+     */
+    buildSelect(fields) {
+        if (fields?.length) {
+            const sel = {};
+            for (const f of fields) {
+                if (this.columns[f])
+                    sel[f] = this.columns[f];
+            }
+            return this.db.select(sel).from(this.table).$dynamic();
+        }
+        return this.db.select().from(this.table).$dynamic();
+    }
+    listWhereToSQL(where) {
+        if (!where || !Object.keys(where).length)
+            return undefined;
+        const conditions = Object.entries(where)
+            .filter(([k]) => this.columns[k])
+            .map(([k, v]) => {
+            const col = this.columns[k];
+            if (v === null)
+                return eq(col, null);
+            if (typeof v === 'object' && v !== null && 'in' in v) {
+                return inArray(col, v.in);
+            }
+            return eq(col, v);
+        });
+        if (!conditions.length)
+            return undefined;
+        return conditions.length === 1 ? conditions[0] : and(...conditions);
+    }
+    withScopeWhere(inner) {
+        if (!this.scope)
+            return inner;
+        const col = this.columns[this.scope.field];
+        if (!col)
+            return inner;
+        const scopeEq = eq(col, this.scope.value);
+        if (!inner)
+            return scopeEq;
+        return and(scopeEq, inner);
+    }
+    stripScope(data) {
+        if (!this.scope)
+            return data;
+        const { [this.scope.field]: _ignored, ...rest } = data;
+        return rest;
+    }
+    async getOne(id, options) {
+        const idWhere = eq(this.columns[this.idField], id);
+        const where = this.withScopeWhere(idWhere);
+        const rows = (await this.buildSelect(options?.fields).where(where));
+        return rows[0] ?? null;
+    }
+    async getMany(options) {
+        const filterWhere = this.listWhereToSQL(options?.where);
+        const where = this.withScopeWhere(filterWhere);
+        const countResult = (await this.db
+            .select({ count: count() })
+            .from(this.table)
+            .where(where));
+        const total = Number(countResult[0]?.count ?? 0);
+        let query = this.buildSelect(options?.fields).where(where);
+        if (options?.orderBy?.length) {
+            const sorts = options.orderBy
+                .filter((s) => this.columns[s.field])
+                .map((s) => {
+                const col = this.columns[s.field];
+                return s.direction === 'desc' ? desc(col) : asc(col);
+            });
+            if (sorts.length)
+                query = query.orderBy(...sorts);
+        }
+        if (options?.limit != null)
+            query = query.limit(options.limit);
+        if (options?.offset != null)
+            query = query.offset(options.offset);
+        const rows = (await query);
+        return { count: total, results: rows };
+    }
+    async createOne(data, _options) {
+        const rows = (await this.db
+            .insert(this.table)
+            .values(this.scope ? { ...data, [this.scope.field]: this.scope.value } : data)
+            .returning());
+        return rows[0];
+    }
+    async createMany(data, _options) {
+        if (!data.length)
+            return [];
+        const stamped = this.scope
+            ? data.map((d) => ({ ...d, [this.scope.field]: this.scope.value }))
+            : data;
+        const rows = (await this.db.insert(this.table).values(stamped).returning());
+        return rows;
+    }
+    async updateOne(id, data) {
+        const idWhere = eq(this.columns[this.idField], id);
+        const where = this.withScopeWhere(idWhere);
+        const rows = (await this.db
+            .update(this.table)
+            .set(this.stripScope(data))
+            .where(where)
+            .returning());
+        return rows[0] ?? null;
+    }
+    async upsertOne(id, data) {
+        const existing = await this.getOne(id);
+        if (existing) {
+            const updated = await this.updateOne(id, data);
+            return updated;
+        }
+        return this.createOne({ ...data, [this.idField]: id });
+    }
+    async updateMany(query, data) {
+        const where = this.withScopeWhere(astToDrizzleWhere(query.where, this.columns));
+        const rows = (await this.db
+            .update(this.table)
+            .set(this.stripScope(data))
+            .where(where)
+            .returning());
+        const ids = rows.map((r) => r[this.idField]);
+        return { updated: ids, results: rows };
+    }
+    async deleteOne(id) {
+        const idWhere = eq(this.columns[this.idField], id);
+        const where = this.withScopeWhere(idWhere);
+        const rows = await this.db.delete(this.table).where(where).returning();
+        return rows.length > 0;
+    }
+    async deleteMany(query) {
+        const where = this.withScopeWhere(astToDrizzleWhere(query.where, this.columns));
+        const rows = (await this.db.delete(this.table).where(where).returning());
+        const deleted = rows.map((r) => r[this.idField]);
+        return { deleted };
+    }
+    async executeQuery(query) {
+        const where = this.withScopeWhere(astToDrizzleWhere(query.where, this.columns));
+        const countResult = (await this.db
+            .select({ count: count() })
+            .from(this.table)
+            .where(where));
+        const total = Number(countResult[0]?.count ?? 0);
+        const sorts = astToDrizzleOrderBy(query.orderBy, this.columns);
+        let q = this.buildSelect(query.fields).where(where);
+        if (sorts.length)
+            q = q.orderBy(...sorts);
+        if (query.limit != null)
+            q = q.limit(query.limit);
+        if (query.offset != null)
+            q = q.offset(query.offset);
+        const rows = (await q);
+        return { count: total, results: rows };
+    }
+    withScope(scope) {
+        return new DrizzleAdapter(this.db, this.table, { idField: this.idField }, scope ?? null);
+    }
+}

package/dist/adapters/orm/drizzle/astToDrizzle.d.ts

@@ -0,0 +1,21 @@
+import type { AnyColumn, SQL } from 'drizzle-orm';
+import type { IQueryFilter, ISort } from '@edium/halifax-types';
+export type ColumnMap = Record<string, AnyColumn>;
+/**
+ * Translates a validated query-builder WHERE tree into Drizzle SQL conditions.
+ *
+ * Logical precedence mirrors the Prisma AST compiler: AND binds tighter than OR, so the
+ * filter list is split into OR-separated groups of AND-runs.
+ *
+ * @param where - The validated filter list from {@link IQueryOptions.where}.
+ * @param columns - Column map derived from `getTableColumns(table)`.
+ * @returns A Drizzle `SQL` condition, or `undefined` when there are no filters.
+ */
+export declare function astToDrizzleWhere(where: IQueryFilter[] | undefined, columns: ColumnMap): SQL | undefined;
+/**
+ * Converts the AST `orderBy` ({@link ISort}[]) into Drizzle order expressions.
+ * @param orderBy - Sort expressions from the query AST.
+ * @param columns - Column map derived from `getTableColumns(table)`.
+ * @returns An array of Drizzle order expressions (empty when there are no sorts).
+ */
+export declare function astToDrizzleOrderBy(orderBy: ISort[] | undefined, columns: ColumnMap): SQL[];

package/dist/adapters/orm/drizzle/astToDrizzle.js

@@ -0,0 +1,121 @@
+import { eq, ne, gt, gte, lt, lte, like, notLike, inArray, notInArray, between, notBetween, isNull, isNotNull, and, or, asc, desc } from 'drizzle-orm';
+import { SqlComparison, SqlOperator, SqlOrder } from '@edium/halifax-types';
+/** Escapes SQL LIKE metacharacters in a literal value so it is treated as a plain string. */
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, '\\$&');
+}
+function comparisonToDrizzle(filter, col) {
+    const v1 = filter.value1;
+    const v2 = filter.value2;
+    const comparison = (filter.comparison?.toUpperCase() ?? '=');
+    switch (comparison) {
+        case SqlComparison.Equal:
+            return eq(col, v1);
+        case SqlComparison.NotEqual:
+            return ne(col, v1);
+        case SqlComparison.GreaterThan:
+            return gt(col, v1);
+        case SqlComparison.GreaterThanOrEqual:
+            return gte(col, v1);
+        case SqlComparison.LessThan:
+            return lt(col, v1);
+        case SqlComparison.LessThanOrEqual:
+            return lte(col, v1);
+        case SqlComparison.In:
+            return inArray(col, (Array.isArray(v1) ? v1 : [v1]));
+        case SqlComparison.NotIn:
+            return notInArray(col, (Array.isArray(v1) ? v1 : [v1]));
+        case SqlComparison.Between:
+            return between(col, v1, v2);
+        case SqlComparison.NotBetween:
+            return notBetween(col, v1, v2);
+        case SqlComparison.IsNull:
+            return isNull(col);
+        case SqlComparison.IsNotNull:
+            return isNotNull(col);
+        case SqlComparison.Contains:
+            return like(col, `%${escapeLike(String(v1 ?? ''))}%`);
+        case SqlComparison.StartsWith:
+            return like(col, `${escapeLike(String(v1 ?? ''))}%`);
+        case SqlComparison.EndsWith:
+            return like(col, `%${escapeLike(String(v1 ?? ''))}`);
+        case SqlComparison.Like:
+            return like(col, String(v1 ?? ''));
+        case SqlComparison.NotLike:
+            return notLike(col, String(v1 ?? ''));
+        default:
+            return eq(col, v1);
+    }
+}
+function nodeToDrizzle(filter, columns) {
+    const col = columns[filter.field];
+    if (!col)
+        return undefined;
+    const self = comparisonToDrizzle(filter, col);
+    if (!self)
+        return undefined;
+    if (filter.children?.length) {
+        const childWhere = astToDrizzleWhere(filter.children, columns);
+        if (!childWhere)
+            return self;
+        return filter.operator?.toUpperCase() === SqlOperator.Or
+            ? or(self, childWhere)
+            : and(self, childWhere);
+    }
+    return self;
+}
+/**
+ * Translates a validated query-builder WHERE tree into Drizzle SQL conditions.
+ *
+ * Logical precedence mirrors the Prisma AST compiler: AND binds tighter than OR, so the
+ * filter list is split into OR-separated groups of AND-runs.
+ *
+ * @param where - The validated filter list from {@link IQueryOptions.where}.
+ * @param columns - Column map derived from `getTableColumns(table)`.
+ * @returns A Drizzle `SQL` condition, or `undefined` when there are no filters.
+ */
+export function astToDrizzleWhere(where, columns) {
+    if (!where?.length)
+        return undefined;
+    const groups = [[]];
+    where.forEach((filter, index) => {
+        groups[groups.length - 1].push(nodeToDrizzle(filter, columns));
+        // A node with children has consumed its operator to join self↔children; only
+        // a childless node's OR starts a new sibling group.
+        const joinsWithOr = !filter.children?.length && filter.operator?.toUpperCase() === SqlOperator.Or;
+        if (joinsWithOr && index < where.length - 1)
+            groups.push([]);
+    });
+    const andify = (group) => {
+        const valid = group.filter(Boolean);
+        if (valid.length === 0)
+            return undefined;
+        if (valid.length === 1)
+            return valid[0];
+        return and(...valid);
+    };
+    if (groups.length === 1)
+        return andify(groups[0]);
+    const orParts = groups.map(andify).filter(Boolean);
+    if (orParts.length === 0)
+        return undefined;
+    if (orParts.length === 1)
+        return orParts[0];
+    return or(...orParts);
+}
+/**
+ * Converts the AST `orderBy` ({@link ISort}[]) into Drizzle order expressions.
+ * @param orderBy - Sort expressions from the query AST.
+ * @param columns - Column map derived from `getTableColumns(table)`.
+ * @returns An array of Drizzle order expressions (empty when there are no sorts).
+ */
+export function astToDrizzleOrderBy(orderBy, columns) {
+    if (!orderBy?.length)
+        return [];
+    return orderBy
+        .filter((sort) => columns[sort.field])
+        .map((sort) => {
+        const col = columns[sort.field];
+        return sort.order.toUpperCase() === SqlOrder.DESC ? desc(col) : asc(col);
+    });
+}

package/dist/adapters/orm/drizzle/index.d.ts

@@ -0,0 +1,4 @@
+export { DrizzleAdapter } from './DrizzleAdapter.js';
+export type { DrizzleAdapterConfig, AnyDrizzleDB } from './DrizzleAdapter.js';
+export { astToDrizzleWhere, astToDrizzleOrderBy } from './astToDrizzle.js';
+export type { ColumnMap } from './astToDrizzle.js';

package/dist/adapters/orm/drizzle/index.js

@@ -0,0 +1,2 @@
+export { DrizzleAdapter } from './DrizzleAdapter.js';
+export { astToDrizzleWhere, astToDrizzleOrderBy } from './astToDrizzle.js';

package/dist/adapters/orm/prisma/PrismaAdapter.d.ts

@@ -1,4 +1,4 @@
-import type { IQueryOptions } from '../../../interfaces/IQueryOptions.js';
+import type { IQueryOptions } from '@edium/halifax-types';
 import type { Repository, RepositoryCapabilities, DeleteManyResult, ListOptions, ListResult, QueryResult, TenantScope, UpdateManyResult } from '../../../core/types.js';
 import type { FieldDefinition, RelationDefinition, ModelSchema } from '../../../core/types.js';
 import type { PrismaAdapterOptions } from './types.js';

package/dist/adapters/orm/prisma/PrismaAdapter.js

@@ -10,6 +10,28 @@ function isNotFoundError(error) {
         error.code === 'P2025');
 }
 import { toSelect, toInclude, toOrderBy } from './helpers.js';
+function prismaTypeToOpenApi(prismaType) {
+    switch (prismaType) {
+        case 'Int':
+            return { type: 'integer', format: 'int32' };
+        case 'BigInt':
+            return { type: 'integer', format: 'int64' };
+        case 'Float':
+            return { type: 'number', format: 'float' };
+        case 'Decimal':
+            return { type: 'number', format: 'double' };
+        case 'Boolean':
+            return { type: 'boolean' };
+        case 'DateTime':
+            return { type: 'string', format: 'date-time' };
+        case 'Json':
+            return { type: 'object' };
+        case 'Bytes':
+            return { type: 'string', format: 'binary' };
+        default:
+            return {};
+    }
+}
 /**
  * PrismaAdapter is a generic repository implementation that uses Prisma delegates to perform
  * database operations. It handles CRUD plus the query-builder/bulk paths by compiling the
@@ -146,7 +168,8 @@ export class PrismaAdapter {
             name: f.name,
             filterable: true,
             sortable: true,
-            writable: !f.isId && !f.isReadOnly
+            writable: !f.isId && !f.isReadOnly,
+            ...prismaTypeToOpenApi(f.type)
         }));
     }
     /**

package/dist/adapters/orm/prisma/astToPrisma.d.ts

@@ -1,5 +1,4 @@
-import type { IQueryFilter } from '../../../interfaces/IQueryFilter.js';
-import type { ISort } from '../../../interfaces/ISort.js';
+import type { IQueryFilter, ISort } from '@edium/halifax-types';
 /** A Prisma `where` fragment — an arbitrary nested object of field conditions and AND/OR/NOT groups. */
 export type PrismaWhere = Record<string, unknown>;
 /**

package/dist/adapters/orm/prisma/astToPrisma.js

@@ -1,6 +1,4 @@
-import { SqlComparison } from '../../../enums/SqlComparison.js';
-import { SqlOperator } from '../../../enums/SqlOperator.js';
-import { SqlOrder } from '../../../enums/SqlOrder.js';
+import { SqlComparison, SqlOperator, SqlOrder } from '@edium/halifax-types';
 /**
  * Splits a `LIKE` pattern into a Prisma string operator based on its `%` wildcards.
  * `%x%` → `contains`, `x%` → `startsWith`, `%x` → `endsWith`, and a wildcard-free value

package/dist/adapters/orm/prisma/helpers.js

@@ -35,7 +35,7 @@ export function toOrderBy(orderBy) {
  * @returns The route prefix, e.g., 'user-profiles'.
  */
 export function toRoutePrefix(modelName) {
-    const kebab = modelName.replace(/([A-Z])/g, (m, l, i) => (i > 0 ? '-' : '') + l.toLowerCase());
+    const kebab = modelName.replace(/([A-Z])/g, (_match, letter, offset) => (offset > 0 ? '-' : '') + letter.toLowerCase());
     if (kebab.endsWith('y') && !/[aeiou]y$/.test(kebab))
         return kebab.slice(0, -1) + 'ies';
     if (/(?:s|x|z|ch|sh)$/.test(kebab))

package/dist/adapters/orm/prisma/types.d.ts

@@ -5,21 +5,21 @@ import type { ModelSchema, ModelResourceOptions, CrudPermissions, TenantScope }
  * and properties, but these are the ones that the adapter will use.
  */
 export interface PrismaDelegate {
-    findUnique?(args: any): Promise<any>;
-    findFirst?(args: any): Promise<any>;
-    findMany(args?: any): Promise<any[]>;
-    count(args?: any): Promise<number>;
-    create(args: any): Promise<any>;
-    createMany?(args: any): Promise<{
+    findUnique?(args: unknown): Promise<unknown>;
+    findFirst?(args: unknown): Promise<unknown>;
+    findMany(args?: unknown): Promise<unknown[]>;
+    count(args?: unknown): Promise<number>;
+    create(args: unknown): Promise<unknown>;
+    createMany?(args: unknown): Promise<{
         count: number;
     }>;
-    update(args: any): Promise<any>;
-    updateMany?(args: any): Promise<{
+    update(args: unknown): Promise<unknown>;
+    updateMany?(args: unknown): Promise<{
         count: number;
     }>;
-    upsert?(args: any): Promise<any>;
-    delete(args: any): Promise<any>;
-    deleteMany?(args: any): Promise<{
+    upsert?(args: unknown): Promise<unknown>;
+    delete(args: unknown): Promise<unknown>;
+    deleteMany?(args: unknown): Promise<{
         count: number;
     }>;
 }