@an5/orm 1.0.7 → 1.0.9

package/dist/sql-utils.d.ts

@@ -0,0 +1,31 @@
+import type { RelationDef } from "./metadata";
+/**
+ * SQL Server identifier quoting.
+ *
+ * Wraps a bare identifier in square brackets and escapes any embedded
+ * closing bracket (`]` → `]]`), which is the only character that can break
+ * out of a bracketed identifier in T-SQL. This blocks SQL injection through
+ * user-supplied column / alias names.
+ */
+export declare function quoteIdentifier(name: string): string;
+/** Quotes one-part or multipart SQL Server table identifiers safely. */
+export declare function quoteTableIdentifier(name: string): string;
+/** Sanitizes a parameter name to a safe T-SQL identifier fragment. */
+export declare function sanitizeParamName(name: string): string;
+/** Validates a direction token, defaulting to ASC. */
+export declare function normalizeSortDirection(dir: unknown): "ASC" | "DESC";
+/** Coerces a value to a non-negative integer, or returns the fallback. */
+export declare function toNonNegativeInt(value: unknown, fallback?: number): number;
+export interface QueryContext {
+    relationMap?: Record<string, Record<string, RelationDef>>;
+    modelToTable?: Record<string, string>;
+}
+export declare function buildOrderBy(orderBy: any): string;
+/**
+ * Recursively builds a WHERE clause from a structured filter object.
+ *
+ * Values are always bound as parameters (`@name`); only identifiers are
+ * interpolated directly, and they are run through {@link quoteIdentifier}.
+ */
+export declare function parseWhere(modelName: string, where: any, params: Record<string, any>, prefix?: string, ctx?: QueryContext): string;
+//# sourceMappingURL=sql-utils.d.ts.map

package/dist/sql-utils.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteIdentifier = quoteIdentifier;
+exports.quoteTableIdentifier = quoteTableIdentifier;
+exports.sanitizeParamName = sanitizeParamName;
+exports.normalizeSortDirection = normalizeSortDirection;
+exports.toNonNegativeInt = toNonNegativeInt;
+exports.buildOrderBy = buildOrderBy;
+exports.parseWhere = parseWhere;
+/**
+ * SQL Server identifier quoting.
+ *
+ * Wraps a bare identifier in square brackets and escapes any embedded
+ * closing bracket (`]` → `]]`), which is the only character that can break
+ * out of a bracketed identifier in T-SQL. This blocks SQL injection through
+ * user-supplied column / alias names.
+ */
+function quoteIdentifier(name) {
+    const s = String(name);
+    return `[${s.replace(/\]/g, "]]")}]`;
+}
+function unquoteBracketIdentifier(part) {
+    const trimmed = String(part).trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        return trimmed.slice(1, -1).replace(/\]\]/g, "]");
+    }
+    return trimmed;
+}
+function splitMultipartIdentifier(name) {
+    const parts = [];
+    let current = "";
+    let inBracket = false;
+    const input = String(name).trim();
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        if (ch === "[")
+            inBracket = true;
+        if (ch === "]") {
+            if (input[i + 1] === "]") {
+                current += "]]";
+                i += 1;
+                continue;
+            }
+            inBracket = false;
+        }
+        if (ch === "." && !inBracket) {
+            if (current.trim())
+                parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts.length > 0 ? parts : [input];
+}
+/** Quotes one-part or multipart SQL Server table identifiers safely. */
+function quoteTableIdentifier(name) {
+    return splitMultipartIdentifier(name)
+        .map(part => quoteIdentifier(unquoteBracketIdentifier(part)))
+        .join(".");
+}
+/** Sanitizes a parameter name to a safe T-SQL identifier fragment. */
+function sanitizeParamName(name) {
+    const s = String(name);
+    const cleaned = s.replace(/[^A-Za-z0-9_]/g, "_");
+    return /^[A-Za-z]/.test(cleaned) ? cleaned : `p_${cleaned}`;
+}
+/** Validates a direction token, defaulting to ASC. */
+function normalizeSortDirection(dir) {
+    const upper = typeof dir === "string" ? dir.toUpperCase() : "";
+    return upper === "DESC" ? "DESC" : "ASC";
+}
+/** Coerces a value to a non-negative integer, or returns the fallback. */
+function toNonNegativeInt(value, fallback = 0) {
+    const n = Number.parseInt(String(value), 10);
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+const OPERATOR_KEYS = ["equals", "in", "notIn", "contains", "startsWith", "endsWith", "not", "gte", "lte", "gt", "lt"];
+function isOperatorValue(value) {
+    if (!value || typeof value !== "object" || value instanceof Date)
+        return false;
+    return OPERATOR_KEYS.some((op) => op in value);
+}
+function buildOrderBy(orderBy) {
+    if (!orderBy)
+        return "";
+    const orderClauses = [];
+    const orderByArr = Array.isArray(orderBy) ? orderBy : [orderBy];
+    for (const orderObj of orderByArr) {
+        if (orderObj && typeof orderObj === "object") {
+            for (const [k, dir] of Object.entries(orderObj)) {
+                orderClauses.push(`${quoteIdentifier(k)} ${normalizeSortDirection(dir)}`);
+            }
+        }
+    }
+    return orderClauses.length > 0 ? ` ORDER BY ${orderClauses.join(", ")}` : "";
+}
+/**
+ * Recursively builds a WHERE clause from a structured filter object.
+ *
+ * Values are always bound as parameters (`@name`); only identifiers are
+ * interpolated directly, and they are run through {@link quoteIdentifier}.
+ */
+function parseWhere(modelName, where, params, prefix = "", ctx = {}) {
+    if (!where)
+        return "";
+    const conditions = [];
+    const relationMap = ctx.relationMap || {};
+    const modelToTable = ctx.modelToTable || {};
+    const cleanWhere = {};
+    for (const [key, value] of Object.entries(where)) {
+        if (key.includes("_") && value && typeof value === "object" && !(value instanceof Date) && !isOperatorValue(value)) {
+            Object.assign(cleanWhere, value);
+        }
+        else {
+            cleanWhere[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(cleanWhere)) {
+        if (key === "OR" && Array.isArray(value)) {
+            const orConditions = value.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}or_${idx}_`, ctx));
+            const filtered = orConditions.filter(Boolean);
+            if (filtered.length > 0) {
+                conditions.push(`(${filtered.join(" OR ")})`);
+            }
+        }
+        else if (key === "AND") {
+            const andItems = Array.isArray(value) ? value : [value];
+            const andConditions = andItems.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}and_${idx}_`, ctx));
+            const filtered = andConditions.filter(Boolean);
+            if (filtered.length > 0) {
+                conditions.push(`(${filtered.join(" AND ")})`);
+            }
+        }
+        else if (key === "NOT") {
+            const notItems = Array.isArray(value) ? value : [value];
+            const notConditions = notItems.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}not_${idx}_`, ctx));
+            const filtered = notConditions.filter(Boolean);
+            if (filtered.length > 0) {
+                conditions.push(`NOT (${filtered.join(" AND ")})`);
+            }
+        }
+        else {
+            const modelRelations = relationMap[modelName];
+            const relation = modelRelations?.[key];
+            if (relation) {
+                const relationTable = quoteTableIdentifier(modelToTable[relation.modelName] || relation.modelName);
+                const subParams = {};
+                let subWhere = value;
+                let op = "some";
+                if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+                    if (value.some) {
+                        subWhere = value.some;
+                        op = "some";
+                    }
+                    else if (value.none) {
+                        subWhere = value.none;
+                        op = "none";
+                    }
+                    else if (value.every) {
+                        subWhere = value.every;
+                        op = "every";
+                    }
+                }
+                const subWhereSql = parseWhere(relation.modelName, subWhere, subParams, `${prefix}${key}_`, ctx);
+                Object.assign(params, subParams);
+                const fk = quoteIdentifier(relation.foreignKey);
+                const lk = quoteIdentifier(relation.localKey);
+                const outerKey = relation.relationType === "one" ? fk : lk;
+                const innerKey = relation.relationType === "one" ? lk : fk;
+                if (op === "every") {
+                    if (subWhereSql) {
+                        conditions.push(`${outerKey} NOT IN (SELECT ${innerKey} FROM ${relationTable} WITH (NOLOCK) WHERE NOT (${subWhereSql}))`);
+                    }
+                    else {
+                        conditions.push("1 = 1");
+                    }
+                }
+                else {
+                    const relationPredicate = subWhereSql ? ` WHERE ${subWhereSql}` : "";
+                    const operator = op === "none" ? "NOT IN" : "IN";
+                    conditions.push(`${outerKey} ${operator} (SELECT ${innerKey} FROM ${relationTable} WITH (NOLOCK)${relationPredicate})`);
+                }
+            }
+            else {
+                const col = quoteIdentifier(key);
+                const paramName = sanitizeParamName(`${prefix}${key}`);
+                if (value && typeof value === "object" && !(value instanceof Date)) {
+                    const ops = Object.entries(value);
+                    for (const [op, opVal] of ops) {
+                        if (op === "equals") {
+                            if (opVal === null) {
+                                conditions.push(`${col} IS NULL`);
+                            }
+                            else {
+                                conditions.push(`${col} = @${paramName}_equals`);
+                                params[`${paramName}_equals`] = opVal;
+                            }
+                        }
+                        else if (op === "in" && Array.isArray(opVal)) {
+                            if (opVal.length === 0) {
+                                conditions.push("1 = 0");
+                            }
+                            else {
+                                const inParams = [];
+                                opVal.forEach((item, idx) => {
+                                    const inParamName = `${paramName}_in_${idx}`;
+                                    inParams.push(`@${inParamName}`);
+                                    params[inParamName] = item;
+                                });
+                                conditions.push(`${col} IN (${inParams.join(", ")})`);
+                            }
+                        }
+                        else if (op === "notIn" && Array.isArray(opVal)) {
+                            if (opVal.length === 0) {
+                                conditions.push("1 = 1");
+                            }
+                            else {
+                                const inParams = [];
+                                opVal.forEach((item, idx) => {
+                                    const inParamName = `${paramName}_notin_${idx}`;
+                                    inParams.push(`@${inParamName}`);
+                                    params[inParamName] = item;
+                                });
+                                conditions.push(`${col} NOT IN (${inParams.join(", ")})`);
+                            }
+                        }
+                        else if (op === "contains") {
+                            conditions.push(`${col} LIKE @${paramName}_contains`);
+                            params[`${paramName}_contains`] = `%${opVal}%`;
+                        }
+                        else if (op === "startsWith") {
+                            conditions.push(`${col} LIKE @${paramName}_startsWith`);
+                            params[`${paramName}_startsWith`] = `${opVal}%`;
+                        }
+                        else if (op === "endsWith") {
+                            conditions.push(`${col} LIKE @${paramName}_endsWith`);
+                            params[`${paramName}_endsWith`] = `%${opVal}`;
+                        }
+                        else if (op === "not") {
+                            if (opVal === null) {
+                                conditions.push(`${col} IS NOT NULL`);
+                            }
+                            else if (opVal && typeof opVal === "object" && !(opVal instanceof Date) && !Array.isArray(opVal)) {
+                                const nestedParams = {};
+                                const nestedSql = parseWhere(modelName, { [key]: opVal }, nestedParams, `${prefix}${key}_not_`, ctx);
+                                Object.assign(params, nestedParams);
+                                if (nestedSql)
+                                    conditions.push(`NOT (${nestedSql})`);
+                            }
+                            else {
+                                conditions.push(`${col} <> @${paramName}_not`);
+                                params[`${paramName}_not`] = opVal;
+                            }
+                        }
+                        else if (op === "gte") {
+                            conditions.push(`${col} >= @${paramName}_gte`);
+                            params[`${paramName}_gte`] = opVal;
+                        }
+                        else if (op === "lte") {
+                            conditions.push(`${col} <= @${paramName}_lte`);
+                            params[`${paramName}_lte`] = opVal;
+                        }
+                        else if (op === "gt") {
+                            conditions.push(`${col} > @${paramName}_gt`);
+                            params[`${paramName}_gt`] = opVal;
+                        }
+                        else if (op === "lt") {
+                            conditions.push(`${col} < @${paramName}_lt`);
+                            params[`${paramName}_lt`] = opVal;
+                        }
+                    }
+                }
+                else {
+                    if (value === null) {
+                        conditions.push(`${col} IS NULL`);
+                    }
+                    else {
+                        conditions.push(`${col} = @${paramName}`);
+                        params[paramName] = value;
+                    }
+                }
+            }
+        }
+    }
+    return conditions.join(" AND ");
+}
+//# sourceMappingURL=sql-utils.js.map

package/generator/src/code-generator.ts

@@ -19,15 +19,11 @@ export class CodeGenerator {
 
   private generateBaseTs() {
     const baseTs = `
+import { An5ClientKnownRequestError as An5KnownError } from "@an5/orm";
+
 export namespace An5 {
-  export class An5ClientKnownRequestError extends Error {
-    code!: string;
-    meta?: any;
-    constructor(message: string, { code, clientVersion }: { code: string; clientVersion: string }) {
-      super(message);
-      this.code = code;
-    }
-  }
+  export const An5ClientKnownRequestError: typeof An5KnownError = An5KnownError;
+  export type An5ClientKnownRequestError = An5KnownError;
   export type SortOrder = 'asc' | 'desc';
   export type StringFilter = { equals?: string; in?: string[]; notIn?: string[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringFilter; };
   export type StringNullableFilter = { equals?: string | null; in?: (string | null)[]; notIn?: (string | null)[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringNullableFilter | null; };
@@ -37,11 +33,11 @@ export namespace An5 {
   export type NumberNullableFilter = { equals?: number | null; in?: (number | null)[]; notIn?: (number | null)[]; lt?: number; lte?: number; gt?: number; gte?: number; not?: number | NumberNullableFilter | null; };
   export type BooleanFilter = { equals?: boolean; not?: boolean | BooleanFilter; };
   export type BooleanNullableFilter = { equals?: boolean | null; not?: boolean | BooleanNullableFilter | null; };
-  export type DateTimeFilter = { equals?: Date; in?: Date[]; notIn?: Date[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeFilter; };
-  export type DateTimeNullableFilter = { equals?: Date | null; in?: (Date | null)[]; notIn?: (Date | null)[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeNullableFilter | null; };
+  export type DateTimeFilter = { equals?: Date | string; in?: (Date | string)[]; notIn?: (Date | string)[]; lt?: Date | string; lte?: Date | string; gt?: Date | string; gte?: Date | string; not?: Date | string | DateTimeFilter; };
+  export type DateTimeNullableFilter = { equals?: Date | string | null; in?: ((Date | string) | null)[]; notIn?: ((Date | string) | null)[]; lt?: Date | string; lte?: Date | string; gt?: Date | string; gte?: Date | string; not?: Date | string | DateTimeNullableFilter | null; };
 }
 
-export interface TableClient<T, WhereInput = any, Select = any, Include = any, CreateInput = any, UpdateInput = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, CreateArgs = any, UpdateArgs = any, UpsertArgs = any, DeleteArgs = any> {
+export interface TableClient<T, WhereInput = any, _Select = any, Include = any, CreateInput = any, UpdateInput = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, CreateArgs = any, UpdateArgs = any, UpsertArgs = any, DeleteArgs = any, AggregateArgs = any, GroupByArgs = any> {
   findMany(args?: FindManyArgs): Promise<T[]>;
   vectorSearch(args: { vector: number[]; take?: number; where?: WhereInput; include?: Include; vectorField?: string; distanceMetric?: 'cosine' | 'euclidean' | 'dot'; }): Promise<(T & { distance: number })[]>;
   findFirst(args?: FindFirstArgs): Promise<T | null>;
@@ -53,8 +49,8 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
   updateMany(args: { where?: WhereInput; data: UpdateInput; }): Promise<{ count: number }>;
   delete(args: DeleteArgs): Promise<T>;
   deleteMany(args?: { where?: WhereInput; }): Promise<{ count: number }>;
-  aggregate(args: any): Promise<any>;
-  groupBy(args: any): Promise<any[]>;
+  aggregate(args: AggregateArgs): Promise<any>;
+  groupBy(args: GroupByArgs): Promise<any[]>;
   upsert(args: UpsertArgs): Promise<T>;
 }
 `;
@@ -88,7 +84,7 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
     content += `  NOT?: ${model.name}WhereInput | ${model.name}WhereInput[];\n`;
     for (const field of model.fields) {
       const filter = this.getFieldFilterType(field);
-      content += `  ${field.name}?: ${field.type} | ${filter}${field.isOptional ? ' | null' : ''};\n`;
+      content += `  ${field.name}?: ${this.inputType(field.type)} | ${filter}${field.isOptional ? ' | null' : ''};\n`;
     }
     for (const rel of model.relations) {
       if (rel.isArray) {
@@ -118,18 +114,25 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
     }
     content += `export type ${model.name}Include = { ${includeRels.join('; ')}${includeRels.length > 0 ? ';' : ''} };\n`;
 
-    content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
-    content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
+    content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
+    content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
 
-    content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: any; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-    content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: any; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+    content += `export type ${model.name}OrderByInput = { ${model.fields.map(f => `${f.name}?: An5.SortOrder`).join('; ')} };\n`;
+    content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+    content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
     content += `export type ${model.name}FindUniqueArgs = { where?: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
     content += `export type ${model.name}CreateArgs = { data: ${model.name}CreateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
     content += `export type ${model.name}UpdateArgs = { where: ${model.name}WhereInput; data: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
     content += `export type ${model.name}UpsertArgs = { where: ${model.name}WhereInput; create: ${model.name}CreateInput; update: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
     content += `export type ${model.name}DeleteArgs = { where: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+    content += `export type ${model.name}ScalarFieldEnum = ${model.fields.map(f => `'${f.name}'`).join(' | ') || 'never'};\n`;
+    content += `export type ${model.name}AggregateArgs = { where?: ${model.name}WhereInput; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
+    const numericHavingFields = model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: An5.NumberFilter | number`).join('; ');
+    const scalarHavingFields = model.fields.map(f => `${f.name}?: any`).join('; ');
+    content += `export type ${model.name}AggregateHavingInput = { _count?: { _all?: An5.NumberFilter | number; ${model.fields.map(f => `${f.name}?: An5.NumberFilter | number`).join('; ')} }; _sum?: { ${numericHavingFields} }; _avg?: { ${numericHavingFields} }; _min?: { ${scalarHavingFields} }; _max?: { ${scalarHavingFields} }; };\n`;
+    content += `export type ${model.name}GroupByArgs = { by: ${model.name}ScalarFieldEnum | ${model.name}ScalarFieldEnum[]; where?: ${model.name}WhereInput; having?: ${model.name}AggregateHavingInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; skip?: number; take?: number; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
 
-    content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs\n>;\n`;
+    content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs,\n  ${model.name}AggregateArgs,\n  ${model.name}GroupByArgs\n>;\n`;
 
     fs.writeFileSync(path.join(this.outputDir, `${model.name}.ts`), content);
   }
@@ -165,10 +168,22 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
       content += `  export type ${model.name}Include = ${model.name}Types.${model.name}Include;\n`;
       content += `  export type ${model.name}CreateInput = ${model.name}Types.${model.name}CreateInput;\n`;
       content += `  export type ${model.name}UpdateInput = ${model.name}Types.${model.name}UpdateInput;\n`;
+      content += `  export type ${model.name}OrderByInput = ${model.name}Types.${model.name}OrderByInput;\n`;
+      content += `  export type ${model.name}FindManyArgs = ${model.name}Types.${model.name}FindManyArgs;\n`;
+      content += `  export type ${model.name}FindFirstArgs = ${model.name}Types.${model.name}FindFirstArgs;\n`;
+      content += `  export type ${model.name}FindUniqueArgs = ${model.name}Types.${model.name}FindUniqueArgs;\n`;
+      content += `  export type ${model.name}CreateArgs = ${model.name}Types.${model.name}CreateArgs;\n`;
+      content += `  export type ${model.name}UpdateArgs = ${model.name}Types.${model.name}UpdateArgs;\n`;
+      content += `  export type ${model.name}UpsertArgs = ${model.name}Types.${model.name}UpsertArgs;\n`;
+      content += `  export type ${model.name}DeleteArgs = ${model.name}Types.${model.name}DeleteArgs;\n`;
+      content += `  export type ${model.name}TableClient = ${model.name}Types.${model.name}TableClient;\n`;
+      content += `  export type ${model.name}ScalarFieldEnum = ${model.name}Types.${model.name}ScalarFieldEnum;\n`;
+      content += `  export type ${model.name}AggregateArgs = ${model.name}Types.${model.name}AggregateArgs;\n`;
+      content += `  export type ${model.name}GroupByArgs = ${model.name}Types.${model.name}GroupByArgs;\n`;
     }
     content += `}\n`;
 
-    content += `\nexport class An5Client {\n  $connect(): Promise<void> { return Promise.resolve(); }\n  $disconnect(): Promise<void> { return Promise.resolve(); }\n  $transaction<R>(fn: (tx: An5Client) => Promise<R>, options?: { timeout?: number }): Promise<R>;\n  $transaction<R>(list: Promise<R>[]): Promise<R[]>;\n  $transaction(fn: any, options?: any): Promise<any> { return typeof fn === 'function' ? fn(this) : Promise.all(fn); }\n  $queryRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<T> { return Promise.resolve([] as any); }\n  $queryRawUnsafe<R = any>(query: string, ...values: any[]): Promise<R> { return Promise.resolve([] as any); }\n  $executeRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<any> { return Promise.resolve(0 as any); }\n  $executeRawUnsafe(query: string, ...values: any[]): Promise<number> { return Promise.resolve(0); }\n`;
+    content += `\nexport class An5Client {\n  $connect(): Promise<void> { return Promise.resolve(); }\n  $disconnect(): Promise<void> { return Promise.resolve(); }\n  $transaction<R>(fn: (tx: An5Client) => Promise<R>, options?: { timeout?: number }): Promise<R>;\n  $transaction<R>(list: Promise<R>[]): Promise<R[]>;\n  $transaction(fn: any, _options?: any): Promise<any> { return typeof fn === 'function' ? fn(this) : Promise.all(fn); }\n  $begin(): Promise<An5Client> { return Promise.resolve(this); }\n  $commit(): Promise<void> { return Promise.resolve(); }\n  $rollback(): Promise<void> { return Promise.resolve(); }\n  $queryRaw<T = any>(_queryParts: TemplateStringsArray | string, ..._values: any[]): Promise<T> { return Promise.resolve([] as any); }\n  $queryRawUnsafe<R = any>(_query: string, ..._values: any[]): Promise<R> { return Promise.resolve([] as any); }\n  $executeRaw<_T = any>(_queryParts: TemplateStringsArray | string, ..._values: any[]): Promise<any> { return Promise.resolve(0 as any); }\n  $executeRawUnsafe(_query: string, ..._values: any[]): Promise<number> { return Promise.resolve(0); }\n`;
 
     const addedProps = new Set<string>();
     for (const model of models) {
@@ -187,12 +202,16 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
 
   private getAllPropertyVariations(modelName: string): string[] {
     const variations = new Set<string>();
+    variations.add(modelName);
     variations.add(this.toCamelCase(modelName));
+    variations.add(modelName + 's');
+    variations.add(this.toCamelCase(modelName) + 's');
     const acronyms = ['LLM', 'AI', 'MCP', 'IT', 'QC', 'HR', 'MR', 'WH', 'SSIS', 'API', 'URL', 'ID', 'JSON'];
     for (const acronym of acronyms) {
       if (modelName.startsWith(acronym)) {
         variations.add(acronym.toLowerCase() + modelName.slice(acronym.length));
         variations.add(acronym[0].toLowerCase() + acronym.slice(1) + modelName.slice(acronym.length));
+        variations.add(acronym.toLowerCase() + modelName.slice(acronym.length) + 's');
       }
     }
     return Array.from(variations);
@@ -207,6 +226,12 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
     return 'any';
   }
 
+  // Input positions (create/update/where scalars) accept ISO strings as well
+  // as Date objects — Prisma parity for DateTime fields.
+  private inputType(tsType: string): string {
+    return tsType === 'Date' ? 'Date | string' : tsType;
+  }
+
   private normalizeType(type: string): string {
     const lowerType = type.toLowerCase();
     if (['string', 'varchar', 'nvarchar', 'char', 'nchar', 'text', 'ntext', 'xml', 'guid', 'uuid', 'uniqueidentifier', 'sysname', 'hierarchyid', 'geography', 'geometry', 'sql_variant', 'sqlvariant', 'rowversion', 'variant'].includes(lowerType)) {