drizzle-zod 1.0.0-beta.9-42ad8bb → 1.0.0-beta.9-c26fd2f

package/index.cjs

@@ -1,403 +1,367 @@
-'use strict';
-
-var drizzleOrm = require('drizzle-orm');
-var v4 = require('zod/v4');
+let drizzle_orm = require("drizzle-orm");
+let zod_v4 = require("zod/v4");
 
+//#region src/constants.ts
 const CONSTANTS = {
-    INT8_MIN: -128,
-    INT8_MAX: 127,
-    INT8_UNSIGNED_MAX: 255,
-    INT16_MIN: -32768,
-    INT16_MAX: 32767,
-    INT16_UNSIGNED_MAX: 65535,
-    INT24_MIN: -8388608,
-    INT24_MAX: 8388607,
-    INT24_UNSIGNED_MAX: 16777215,
-    INT32_MIN: -2147483648,
-    INT32_MAX: 2147483647,
-    INT32_UNSIGNED_MAX: 4294967295,
-    INT48_MIN: -140737488355328,
-    INT48_MAX: 140737488355327,
-    INT48_UNSIGNED_MAX: 281474976710655,
-    INT64_MIN: -9223372036854775808n,
-    INT64_MAX: 9223372036854775807n,
-    INT64_UNSIGNED_MAX: 18446744073709551615n,
+	INT8_MIN: -128,
+	INT8_MAX: 127,
+	INT8_UNSIGNED_MAX: 255,
+	INT16_MIN: -32768,
+	INT16_MAX: 32767,
+	INT16_UNSIGNED_MAX: 65535,
+	INT24_MIN: -8388608,
+	INT24_MAX: 8388607,
+	INT24_UNSIGNED_MAX: 16777215,
+	INT32_MIN: -2147483648,
+	INT32_MAX: 2147483647,
+	INT32_UNSIGNED_MAX: 4294967295,
+	INT48_MIN: -0x800000000000,
+	INT48_MAX: 0x7fffffffffff,
+	INT48_UNSIGNED_MAX: 0xffffffffffff,
+	INT64_MIN: -9223372036854775808n,
+	INT64_MAX: 9223372036854775807n,
+	INT64_UNSIGNED_MAX: 18446744073709551615n
 };
 
-const literalSchema = v4.z.union([v4.z.string(), v4.z.number(), v4.z.boolean(), v4.z.null()]);
-const jsonSchema = v4.z.union([
-    literalSchema,
-    v4.z.record(v4.z.string(), v4.z.any()),
-    v4.z.array(v4.z.any()),
+//#endregion
+//#region src/column.ts
+const literalSchema = zod_v4.z.union([
+	zod_v4.z.string(),
+	zod_v4.z.number(),
+	zod_v4.z.boolean(),
+	zod_v4.z.null()
+]);
+const jsonSchema = zod_v4.z.union([
+	literalSchema,
+	zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any()),
+	zod_v4.z.array(zod_v4.z.any())
 ]);
-const bufferSchema = v4.z.custom((v) => v instanceof Buffer);
+const bufferSchema = zod_v4.z.custom((v) => v instanceof Buffer);
 function columnToSchema(column, factory) {
-    const z = factory?.zodInstance ?? v4.z;
-    const coerce = factory?.coerce ?? {};
-    let schema;
-    const { type, constraint } = drizzleOrm.extractExtendedColumnType(column);
-    switch (type) {
-        case 'array': {
-            schema = arrayColumnToSchema(column, constraint, z, coerce);
-            break;
-        }
-        case 'object': {
-            schema = objectColumnToSchema(column, constraint, z, coerce);
-            break;
-        }
-        case 'number': {
-            schema = numberColumnToSchema(column, constraint, z, coerce);
-            break;
-        }
-        case 'bigint': {
-            schema = bigintColumnToSchema(column, constraint, z, coerce);
-            break;
-        }
-        case 'boolean': {
-            schema = coerce === true || coerce.boolean ? z.coerce.boolean() : z.boolean();
-            break;
-        }
-        case 'string': {
-            schema = stringColumnToSchema(column, constraint, z, coerce);
-            break;
-        }
-        case 'custom': {
-            schema = z.any();
-            break;
-        }
-        default: {
-            schema = z.any();
-        }
-    }
-    return schema;
+	const z$1 = factory?.zodInstance ?? zod_v4.z;
+	const coerce = factory?.coerce ?? {};
+	let schema;
+	const dimensions = column.dimensions;
+	if (typeof dimensions === "number" && dimensions > 0) return pgArrayColumnToSchema(column, dimensions, z$1, coerce);
+	const { type, constraint } = (0, drizzle_orm.extractExtendedColumnType)(column);
+	switch (type) {
+		case "array":
+			schema = arrayColumnToSchema(column, constraint, z$1, coerce);
+			break;
+		case "object":
+			schema = objectColumnToSchema(column, constraint, z$1, coerce);
+			break;
+		case "number":
+			schema = numberColumnToSchema(column, constraint, z$1, coerce);
+			break;
+		case "bigint":
+			schema = bigintColumnToSchema(column, constraint, z$1, coerce);
+			break;
+		case "boolean":
+			schema = coerce === true || coerce.boolean ? z$1.coerce.boolean() : z$1.boolean();
+			break;
+		case "string":
+			schema = stringColumnToSchema(column, constraint, z$1, coerce);
+			break;
+		case "custom":
+			schema = z$1.any();
+			break;
+		default: schema = z$1.any();
+	}
+	return schema;
 }
-function numberColumnToSchema(column, constraint, z, coerce) {
-    let min;
-    let max;
-    let integer = false;
-    switch (constraint) {
-        case 'int8': {
-            min = CONSTANTS.INT8_MIN;
-            max = CONSTANTS.INT8_MAX;
-            integer = true;
-            break;
-        }
-        case 'uint8': {
-            min = 0;
-            max = CONSTANTS.INT8_UNSIGNED_MAX;
-            integer = true;
-            break;
-        }
-        case 'int16': {
-            min = CONSTANTS.INT16_MIN;
-            max = CONSTANTS.INT16_MAX;
-            integer = true;
-            break;
-        }
-        case 'uint16': {
-            min = 0;
-            max = CONSTANTS.INT16_UNSIGNED_MAX;
-            integer = true;
-            break;
-        }
-        case 'int24': {
-            min = CONSTANTS.INT24_MIN;
-            max = CONSTANTS.INT24_MAX;
-            integer = true;
-            break;
-        }
-        case 'uint24': {
-            min = 0;
-            max = CONSTANTS.INT24_UNSIGNED_MAX;
-            integer = true;
-            break;
-        }
-        case 'int32': {
-            min = CONSTANTS.INT32_MIN;
-            max = CONSTANTS.INT32_MAX;
-            integer = true;
-            break;
-        }
-        case 'uint32': {
-            min = 0;
-            max = CONSTANTS.INT32_UNSIGNED_MAX;
-            integer = true;
-            break;
-        }
-        case 'int53': {
-            min = Number.MIN_SAFE_INTEGER;
-            max = Number.MAX_SAFE_INTEGER;
-            integer = true;
-            break;
-        }
-        case 'uint53': {
-            min = 0;
-            max = Number.MAX_SAFE_INTEGER;
-            integer = true;
-            break;
-        }
-        case 'float': {
-            min = CONSTANTS.INT24_MIN;
-            max = CONSTANTS.INT24_MAX;
-            break;
-        }
-        case 'ufloat': {
-            min = 0;
-            max = CONSTANTS.INT24_UNSIGNED_MAX;
-            break;
-        }
-        case 'double': {
-            min = CONSTANTS.INT48_MIN;
-            max = CONSTANTS.INT48_MAX;
-            break;
-        }
-        case 'udouble': {
-            min = 0;
-            max = CONSTANTS.INT48_UNSIGNED_MAX;
-            break;
-        }
-        case 'year': {
-            min = 1901;
-            max = 2155;
-            integer = true;
-            break;
-        }
-        case 'unsigned': {
-            min = 0;
-            max = Number.MAX_SAFE_INTEGER;
-            break;
-        }
-        default: {
-            min = Number.MIN_SAFE_INTEGER;
-            max = Number.MAX_SAFE_INTEGER;
-            break;
-        }
-    }
-    let schema = coerce === true || coerce?.number
-        ? integer ? z.coerce.number().int() : z.coerce.number()
-        : integer
-            ? z.int()
-            : z.number();
-    schema = schema.gte(min).lte(max);
-    return schema;
+function numberColumnToSchema(column, constraint, z$1, coerce) {
+	let min;
+	let max;
+	let integer = false;
+	switch (constraint) {
+		case "int8":
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		case "uint8":
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		case "int16":
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		case "uint16":
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		case "int24":
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		case "uint24":
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		case "int32":
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		case "uint32":
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		case "int53":
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		case "uint53":
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		case "float":
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		case "ufloat":
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		case "double":
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		case "udouble":
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		case "year":
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		case "unsigned":
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		default:
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+	}
+	let schema = coerce === true || coerce?.number ? integer ? z$1.coerce.number().int() : z$1.coerce.number() : integer ? z$1.int() : z$1.number();
+	schema = schema.gte(min).lte(max);
+	return schema;
 }
 /** @internal */
-const bigintStringModeSchema = v4.z.string().regex(/^-?\d+$/).transform(BigInt).pipe(v4.z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX)).transform(String);
+const bigintStringModeSchema = zod_v4.z.string().regex(/^-?\d+$/).transform(BigInt).pipe(zod_v4.z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX)).transform(String);
 /** @internal */
-const unsignedBigintStringModeSchema = v4.z.string().regex(/^\d+$/).transform(BigInt).pipe(v4.z.bigint().gte(0n).lte(CONSTANTS.INT64_MAX)).transform(String);
-function bigintColumnToSchema(column, constraint, z, coerce) {
-    let min;
-    let max;
-    switch (constraint) {
-        case 'int64': {
-            min = CONSTANTS.INT64_MIN;
-            max = CONSTANTS.INT64_MAX;
-            break;
-        }
-        case 'uint64': {
-            min = 0n;
-            max = CONSTANTS.INT64_UNSIGNED_MAX;
-            break;
-        }
-    }
-    let schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
-    if (min !== undefined)
-        schema = schema.min(min);
-    if (max !== undefined)
-        schema = schema.max(max);
-    return schema;
+const unsignedBigintStringModeSchema = zod_v4.z.string().regex(/^\d+$/).transform(BigInt).pipe(zod_v4.z.bigint().gte(0n).lte(CONSTANTS.INT64_MAX)).transform(String);
+function bigintColumnToSchema(column, constraint, z$1, coerce) {
+	let min;
+	let max;
+	switch (constraint) {
+		case "int64":
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		case "uint64":
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+	}
+	let schema = coerce === true || coerce?.bigint ? z$1.coerce.bigint() : z$1.bigint();
+	if (min !== void 0) schema = schema.min(min);
+	if (max !== void 0) schema = schema.max(max);
+	return schema;
+}
+function pgArrayColumnToSchema(column, dimensions, z$1, coerce) {
+	const [baseType, baseConstraint] = column.dataType.split(" ");
+	let baseSchema;
+	switch (baseType) {
+		case "number":
+			baseSchema = numberColumnToSchema(column, baseConstraint, z$1, coerce);
+			break;
+		case "bigint":
+			baseSchema = bigintColumnToSchema(column, baseConstraint, z$1, coerce);
+			break;
+		case "boolean":
+			baseSchema = coerce === true || coerce?.boolean ? z$1.coerce.boolean() : z$1.boolean();
+			break;
+		case "string":
+			baseSchema = stringColumnToSchema(column, baseConstraint, z$1, coerce);
+			break;
+		case "object":
+			baseSchema = objectColumnToSchema(column, baseConstraint, z$1, coerce);
+			break;
+		case "array":
+			baseSchema = arrayColumnToSchema(column, baseConstraint, z$1, coerce);
+			break;
+		default: baseSchema = z$1.any();
+	}
+	let schema = z$1.array(baseSchema);
+	for (let i = 1; i < dimensions; i++) schema = z$1.array(schema);
+	return schema;
 }
-function arrayColumnToSchema(column, constraint, z, coerce) {
-    switch (constraint) {
-        case 'geometry':
-        case 'point': {
-            return z.tuple([z.number(), z.number()]);
-        }
-        case 'line': {
-            return z.tuple([z.number(), z.number(), z.number()]);
-        }
-        case 'vector':
-        case 'halfvector': {
-            const length = column.length;
-            return length
-                ? z.array(z.number()).length(length)
-                : z.array(z.number());
-        }
-        case 'int64vector': {
-            const length = column.length;
-            return length
-                ? z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX)).length(length)
-                : z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX));
-        }
-        case 'basecolumn': {
-            const length = column.length;
-            const schema = column.baseColumn
-                ? z.array(columnToSchema(column.baseColumn, {
-                    zodInstance: z,
-                    coerce,
-                }))
-                : z.array(z.any());
-            if (length)
-                return schema.length(length);
-            return schema;
-        }
-        default: {
-            return z.array(z.any());
-        }
-    }
+function arrayColumnToSchema(column, constraint, z$1, coerce) {
+	switch (constraint) {
+		case "geometry":
+		case "point": return z$1.tuple([z$1.number(), z$1.number()]);
+		case "line": return z$1.tuple([
+			z$1.number(),
+			z$1.number(),
+			z$1.number()
+		]);
+		case "vector":
+		case "halfvector": {
+			const length = column.length;
+			return length ? z$1.array(z$1.number()).length(length) : z$1.array(z$1.number());
+		}
+		case "int64vector": {
+			const length = column.length;
+			return length ? z$1.array(z$1.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX)).length(length) : z$1.array(z$1.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX));
+		}
+		case "basecolumn": {
+			const baseColumn = column.baseColumn;
+			if (baseColumn) {
+				const baseSchema = columnToSchema(baseColumn, {
+					zodInstance: z$1,
+					coerce
+				});
+				const length = column.length;
+				const schema = z$1.array(baseSchema);
+				if (length) return schema.length(length);
+				return schema;
+			}
+			return z$1.array(z$1.any());
+		}
+		default: return z$1.array(z$1.any());
+	}
 }
-function objectColumnToSchema(column, constraint, z, coerce) {
-    switch (constraint) {
-        case 'buffer': {
-            return bufferSchema;
-        }
-        case 'date': {
-            return coerce === true || coerce?.date ? z.coerce.date() : z.date();
-        }
-        case 'geometry':
-        case 'point': {
-            return z.object({
-                x: z.number(),
-                y: z.number(),
-            });
-        }
-        case 'json': {
-            return jsonSchema;
-        }
-        case 'line': {
-            return z.object({
-                a: z.number(),
-                b: z.number(),
-                c: z.number(),
-            });
-        }
-        default: {
-            return z.looseObject({});
-        }
-    }
+function objectColumnToSchema(column, constraint, z$1, coerce) {
+	switch (constraint) {
+		case "buffer": return bufferSchema;
+		case "date": return coerce === true || coerce?.date ? z$1.coerce.date() : z$1.date();
+		case "geometry":
+		case "point": return z$1.object({
+			x: z$1.number(),
+			y: z$1.number()
+		});
+		case "json": return jsonSchema;
+		case "line": return z$1.object({
+			a: z$1.number(),
+			b: z$1.number(),
+			c: z$1.number()
+		});
+		default: return z$1.looseObject({});
+	}
 }
-function stringColumnToSchema(column, constraint, z, coerce) {
-    const { name: columnName, length, isLengthExact } = column;
-    let regex;
-    if (constraint === 'binary') {
-        regex = /^[01]*$/;
-    }
-    if (constraint === 'uuid')
-        return z.uuid();
-    if (constraint === 'enum') {
-        const enumValues = column.enumValues;
-        if (!enumValues) {
-            throw new Error(`Column "${drizzleOrm.getTableName(drizzleOrm.getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`);
-        }
-        return z.enum(enumValues);
-    }
-    if (constraint === 'int64') {
-        return bigintStringModeSchema;
-    }
-    if (constraint === 'uint64') {
-        return unsignedBigintStringModeSchema;
-    }
-    let schema = coerce === true || coerce?.string ? z.coerce.string() : z.string();
-    schema = regex ? schema.regex(regex) : schema;
-    return length && isLengthExact ? schema.length(length) : length ? schema.max(length) : schema;
+function stringColumnToSchema(column, constraint, z$1, coerce) {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex;
+	if (constraint === "binary") regex = /^[01]*$/;
+	if (constraint === "uuid") return z$1.uuid();
+	if (constraint === "enum") {
+		const enumValues = column.enumValues;
+		if (!enumValues) throw new Error(`Column "${(0, drizzle_orm.getTableName)((0, drizzle_orm.getColumnTable)(column))}"."${columnName}" is of 'enum' type, but lacks enum values`);
+		return z$1.enum(enumValues);
+	}
+	if (constraint === "int64") return bigintStringModeSchema;
+	if (constraint === "uint64") return unsignedBigintStringModeSchema;
+	let schema = coerce === true || coerce?.string ? z$1.coerce.string() : z$1.string();
+	schema = regex ? schema.regex(regex) : schema;
+	return length && isLengthExact ? schema.length(length) : length ? schema.max(length) : schema;
 }
 
+//#endregion
+//#region src/utils.ts
 function isWithEnum(column) {
-    return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
+	return "enumValues" in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
 }
 const isPgEnum = isWithEnum;
 
+//#endregion
+//#region src/schema.ts
 function getColumns(tableLike) {
-    return drizzleOrm.isTable(tableLike) ? drizzleOrm.getTableColumns(tableLike) : drizzleOrm.getViewSelectedFields(tableLike);
+	return (0, drizzle_orm.isTable)(tableLike) ? (0, drizzle_orm.getTableColumns)(tableLike) : (0, drizzle_orm.getViewSelectedFields)(tableLike);
 }
 function handleColumns(columns, refinements, conditions, factory) {
-    const columnSchemas = {};
-    for (const [key, selected] of Object.entries(columns)) {
-        if (!drizzleOrm.is(selected, drizzleOrm.Column) && !drizzleOrm.is(selected, drizzleOrm.SQL) && !drizzleOrm.is(selected, drizzleOrm.SQL.Aliased) && typeof selected === 'object') {
-            const columns = drizzleOrm.isTable(selected) || drizzleOrm.isView(selected) ? getColumns(selected) : selected;
-            columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
-            continue;
-        }
-        const refinement = refinements[key];
-        if (refinement !== undefined && typeof refinement !== 'function') {
-            columnSchemas[key] = refinement;
-            continue;
-        }
-        const column = drizzleOrm.is(selected, drizzleOrm.Column) ? selected : undefined;
-        const schema = column ? columnToSchema(column, factory) : v4.z.any();
-        const refined = typeof refinement === 'function' ? refinement(schema) : schema;
-        if (conditions.never(column)) {
-            continue;
-        }
-        else {
-            columnSchemas[key] = refined;
-        }
-        if (column) {
-            if (conditions.nullable(column)) {
-                columnSchemas[key] = columnSchemas[key].nullable();
-            }
-            if (conditions.optional(column)) {
-                columnSchemas[key] = columnSchemas[key].optional();
-            }
-        }
-    }
-    return v4.z.object(columnSchemas);
+	const columnSchemas = {};
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!(0, drizzle_orm.is)(selected, drizzle_orm.Column) && !(0, drizzle_orm.is)(selected, drizzle_orm.SQL) && !(0, drizzle_orm.is)(selected, drizzle_orm.SQL.Aliased) && typeof selected === "object") {
+			columnSchemas[key] = handleColumns((0, drizzle_orm.isTable)(selected) || (0, drizzle_orm.isView)(selected) ? getColumns(selected) : selected, refinements[key] ?? {}, conditions, factory);
+			continue;
+		}
+		const refinement = refinements[key];
+		if (refinement !== void 0 && typeof refinement !== "function") {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+		const column = (0, drizzle_orm.is)(selected, drizzle_orm.Column) ? selected : void 0;
+		const schema = column ? columnToSchema(column, factory) : zod_v4.z.any();
+		const refined = typeof refinement === "function" ? refinement(schema) : schema;
+		if (conditions.never(column)) continue;
+		else columnSchemas[key] = refined;
+		if (column) {
+			if (conditions.nullable(column)) columnSchemas[key] = columnSchemas[key].nullable();
+			if (conditions.optional(column)) columnSchemas[key] = columnSchemas[key].optional();
+		}
+	}
+	return zod_v4.z.object(columnSchemas);
 }
 function handleEnum(enum_, factory) {
-    const zod = factory?.zodInstance ?? v4.z;
-    return zod.enum(enum_.enumValues);
+	return (factory?.zodInstance ?? zod_v4.z).enum(enum_.enumValues);
 }
 const selectConditions = {
-    never: () => false,
-    optional: () => false,
-    nullable: (column) => !column.notNull,
+	never: () => false,
+	optional: () => false,
+	nullable: (column) => !column.notNull
 };
 const insertConditions = {
-    never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
-        || ('identity' in (column ?? {}) && typeof column?.identity !== 'undefined'),
-    optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
-    nullable: (column) => !column.notNull,
+	never: (column) => column?.generated?.type === "always" || column?.generatedIdentity?.type === "always" || "identity" in (column ?? {}) && typeof column?.identity !== "undefined",
+	optional: (column) => !column.notNull || column.notNull && column.hasDefault,
+	nullable: (column) => !column.notNull
 };
 const updateConditions = {
-    never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
-        || ('identity' in (column ?? {}) && typeof column?.identity !== 'undefined'),
-    optional: () => true,
-    nullable: (column) => !column.notNull,
+	never: (column) => column?.generated?.type === "always" || column?.generatedIdentity?.type === "always" || "identity" in (column ?? {}) && typeof column?.identity !== "undefined",
+	optional: () => true,
+	nullable: (column) => !column.notNull
 };
 const createSelectSchema = (entity, refine) => {
-    if (isPgEnum(entity)) {
-        return handleEnum(entity);
-    }
-    const columns = getColumns(entity);
-    return handleColumns(columns, refine ?? {}, selectConditions);
+	if (isPgEnum(entity)) return handleEnum(entity);
+	return handleColumns(getColumns(entity), refine ?? {}, selectConditions);
 };
 const createInsertSchema = (entity, refine) => {
-    const columns = getColumns(entity);
-    return handleColumns(columns, refine ?? {}, insertConditions);
+	return handleColumns(getColumns(entity), refine ?? {}, insertConditions);
 };
 const createUpdateSchema = (entity, refine) => {
-    const columns = getColumns(entity);
-    return handleColumns(columns, refine ?? {}, updateConditions);
+	return handleColumns(getColumns(entity), refine ?? {}, updateConditions);
 };
 function createSchemaFactory(options) {
-    const createSelectSchema = (entity, refine) => {
-        if (isPgEnum(entity)) {
-            return handleEnum(entity, options);
-        }
-        const columns = getColumns(entity);
-        return handleColumns(columns, refine ?? {}, selectConditions, options);
-    };
-    const createInsertSchema = (entity, refine) => {
-        const columns = getColumns(entity);
-        return handleColumns(columns, refine ?? {}, insertConditions, options);
-    };
-    const createUpdateSchema = (entity, refine) => {
-        const columns = getColumns(entity);
-        return handleColumns(columns, refine ?? {}, updateConditions, options);
-    };
-    return { createSelectSchema, createInsertSchema, createUpdateSchema };
+	const createSelectSchema$1 = (entity, refine) => {
+		if (isPgEnum(entity)) return handleEnum(entity, options);
+		return handleColumns(getColumns(entity), refine ?? {}, selectConditions, options);
+	};
+	const createInsertSchema$1 = (entity, refine) => {
+		return handleColumns(getColumns(entity), refine ?? {}, insertConditions, options);
+	};
+	const createUpdateSchema$1 = (entity, refine) => {
+		return handleColumns(getColumns(entity), refine ?? {}, updateConditions, options);
+	};
+	return {
+		createSelectSchema: createSelectSchema$1,
+		createInsertSchema: createInsertSchema$1,
+		createUpdateSchema: createUpdateSchema$1
+	};
 }
 
+//#endregion
 exports.bufferSchema = bufferSchema;
 exports.createInsertSchema = createInsertSchema;
 exports.createSchemaFactory = createSchemaFactory;
@@ -407,4 +371,4 @@ exports.isPgEnum = isPgEnum;
 exports.isWithEnum = isWithEnum;
 exports.jsonSchema = jsonSchema;
 exports.literalSchema = literalSchema;
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map