drizzle-typebox 1.0.0-beta.6-cefee57 → 1.0.0-beta.6-7419dcb

package/index.cjs

@@ -1,406 +1,452 @@
-let _sinclair_typebox = require("@sinclair/typebox");
-let drizzle_orm = require("drizzle-orm");
+'use strict';
+
+var typebox = require('@sinclair/typebox');
+var drizzleOrm = require('drizzle-orm');
 
-//#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: -0x800000000000,
-	INT48_MAX: 0x7fffffffffff,
-	INT48_UNSIGNED_MAX: 0xffffffffffff,
-	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: -140737488355328,
+    INT48_MAX: 140737488355327,
+    INT48_UNSIGNED_MAX: 281474976710655,
+    INT64_MIN: -9223372036854775808n,
+    INT64_MAX: 9223372036854775807n,
+    INT64_UNSIGNED_MAX: 18446744073709551615n,
 };
 
-//#endregion
-//#region src/column.ts
-const literalSchema = _sinclair_typebox.Type.Union([
-	_sinclair_typebox.Type.String(),
-	_sinclair_typebox.Type.Number(),
-	_sinclair_typebox.Type.Boolean(),
-	_sinclair_typebox.Type.Null()
-]);
-const jsonSchema = _sinclair_typebox.Type.Union([
-	literalSchema,
-	_sinclair_typebox.Type.Array(_sinclair_typebox.Type.Any()),
-	_sinclair_typebox.Type.Record(_sinclair_typebox.Type.String(), _sinclair_typebox.Type.Any())
-]);
-_sinclair_typebox.TypeRegistry.Set("Buffer", (_, value) => value instanceof Buffer);
-const bufferSchema = {
-	[_sinclair_typebox.Kind]: "Buffer",
-	type: "buffer"
-};
+const literalSchema = typebox.Type.Union([typebox.Type.String(), typebox.Type.Number(), typebox.Type.Boolean(), typebox.Type.Null()]);
+const jsonSchema = typebox.Type.Union([literalSchema, typebox.Type.Array(typebox.Type.Any()), typebox.Type.Record(typebox.Type.String(), typebox.Type.Any())]);
+typebox.TypeRegistry.Set('Buffer', (_, value) => value instanceof Buffer);
+const bufferSchema = { [typebox.Kind]: 'Buffer', type: 'buffer' };
 function mapEnumValues(values) {
-	return Object.fromEntries(values.map((value) => [value, value]));
+    return Object.fromEntries(values.map((value) => [value, value]));
 }
-function columnToSchema(column, t$2) {
-	let schema;
-	const dimensions = column.dimensions;
-	if (typeof dimensions === "number" && dimensions > 0) return pgArrayColumnToSchema(column, dimensions, t$2);
-	const { type, constraint } = (0, drizzle_orm.extractExtendedColumnType)(column);
-	switch (type) {
-		case "array":
-			schema = arrayColumnToSchema(column, constraint, t$2);
-			break;
-		case "object":
-			schema = objectColumnToSchema(column, constraint, t$2);
-			break;
-		case "number":
-			schema = numberColumnToSchema(column, constraint, t$2);
-			break;
-		case "bigint":
-			schema = bigintColumnToSchema(column, constraint, t$2);
-			break;
-		case "boolean":
-			schema = t$2.Boolean();
-			break;
-		case "string":
-			schema = stringColumnToSchema(column, constraint, t$2);
-			break;
-		case "custom":
-			schema = t$2.Any();
-			break;
-		default: schema = t$2.Any();
-	}
-	return schema;
+function columnToSchema(column, t) {
+    let schema;
+    const { type, constraint } = drizzleOrm.extractExtendedColumnType(column);
+    switch (type) {
+        case 'array': {
+            schema = arrayColumnToSchema(column, constraint, t);
+            break;
+        }
+        case 'object': {
+            schema = objectColumnToSchema(column, constraint, t);
+            break;
+        }
+        case 'number': {
+            schema = numberColumnToSchema(column, constraint, t);
+            break;
+        }
+        case 'bigint': {
+            schema = bigintColumnToSchema(column, constraint, t);
+            break;
+        }
+        case 'boolean': {
+            schema = t.Boolean();
+            break;
+        }
+        case 'string': {
+            schema = stringColumnToSchema(column, constraint, t);
+            break;
+        }
+        case 'custom': {
+            schema = t.Any();
+            break;
+        }
+        default: {
+            schema = t.Any();
+        }
+    }
+    return schema;
 }
-function numberColumnToSchema(column, constraint, t$2) {
-	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;
-	}
-	return t$2[integer ? "Integer" : "Number"]({
-		minimum: min,
-		maximum: max
-	});
+function numberColumnToSchema(column, constraint, t) {
+    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;
+        }
+    }
+    const key = integer ? 'Integer' : 'Number';
+    return t[key]({
+        minimum: min,
+        maximum: max,
+    });
 }
-_sinclair_typebox.TypeRegistry.Set("BigIntStringMode", (_, value) => {
-	if (typeof value !== "string" || !/^-?\d+$/.test(value)) return false;
-	const bigint = BigInt(value);
-	if (bigint < CONSTANTS.INT64_MIN || bigint > CONSTANTS.INT64_MAX) return false;
-	return true;
+typebox.TypeRegistry.Set('BigIntStringMode', (_, value) => {
+    if (typeof value !== 'string' || !(/^-?\d+$/.test(value))) {
+        return false;
+    }
+    const bigint = BigInt(value);
+    if (bigint < CONSTANTS.INT64_MIN || bigint > CONSTANTS.INT64_MAX) {
+        return false;
+    }
+    return true;
 });
-_sinclair_typebox.TypeRegistry.Set("UnsignedBigIntStringMode", (_, value) => {
-	if (typeof value !== "string" || !/^\d+$/.test(value)) return false;
-	const bigint = BigInt(value);
-	if (bigint < 0 || bigint > CONSTANTS.INT64_MAX) return false;
-	return true;
+typebox.TypeRegistry.Set('UnsignedBigIntStringMode', (_, value) => {
+    if (typeof value !== 'string' || !(/^\d+$/.test(value))) {
+        return false;
+    }
+    const bigint = BigInt(value);
+    if (bigint < 0 || bigint > CONSTANTS.INT64_MAX) {
+        return false;
+    }
+    return true;
 });
 /** @internal */
 const bigintStringModeSchema = {
-	[_sinclair_typebox.Kind]: "BigIntStringMode",
-	type: "string"
+    [typebox.Kind]: 'BigIntStringMode',
+    type: 'string',
 };
 /** @internal */
 const unsignedBigintStringModeSchema = {
-	[_sinclair_typebox.Kind]: "UnsignedBigIntStringMode",
-	type: "string"
+    [typebox.Kind]: 'UnsignedBigIntStringMode',
+    type: 'string',
 };
-function pgArrayColumnToSchema(column, dimensions, t$2) {
-	const [baseType, baseConstraint] = column.dataType.split(" ");
-	let baseSchema;
-	switch (baseType) {
-		case "number":
-			baseSchema = numberColumnToSchema(column, baseConstraint, t$2);
-			break;
-		case "bigint":
-			baseSchema = bigintColumnToSchema(column, baseConstraint, t$2);
-			break;
-		case "boolean":
-			baseSchema = t$2.Boolean();
-			break;
-		case "string":
-			baseSchema = stringColumnToSchema(column, baseConstraint, t$2);
-			break;
-		case "object":
-			baseSchema = objectColumnToSchema(column, baseConstraint, t$2);
-			break;
-		case "array":
-			baseSchema = arrayColumnToSchema(column, baseConstraint, t$2);
-			break;
-		default: baseSchema = t$2.Any();
-	}
-	let schema = t$2.Array(baseSchema);
-	for (let i = 1; i < dimensions; i++) schema = t$2.Array(schema);
-	return schema;
-}
-function arrayColumnToSchema(column, constraint, t$2) {
-	switch (constraint) {
-		case "geometry":
-		case "point": return t$2.Tuple([t$2.Number(), t$2.Number()]);
-		case "line": return t$2.Tuple([
-			t$2.Number(),
-			t$2.Number(),
-			t$2.Number()
-		]);
-		case "vector":
-		case "halfvector": {
-			const length = column.length;
-			const sizeParam = length ? {
-				minItems: length,
-				maxItems: length
-			} : void 0;
-			return t$2.Array(t$2.Number(), sizeParam);
-		}
-		case "int64vector": {
-			const length = column.length;
-			const sizeParam = length ? {
-				minItems: length,
-				maxItems: length
-			} : void 0;
-			return t$2.Array(t$2.BigInt({
-				minimum: CONSTANTS.INT64_MIN,
-				maximum: CONSTANTS.INT64_MAX
-			}), sizeParam);
-		}
-		case "basecolumn": {
-			const baseColumn = column.baseColumn;
-			if (baseColumn) {
-				const size = column.length;
-				const sizeParam = size ? {
-					minItems: size,
-					maxItems: size
-				} : void 0;
-				return t$2.Array(columnToSchema(baseColumn, t$2), sizeParam);
-			}
-			return t$2.Array(t$2.Any());
-		}
-		default: return t$2.Array(t$2.Any());
-	}
+function arrayColumnToSchema(column, constraint, t) {
+    switch (constraint) {
+        case 'geometry':
+        case 'point': {
+            return t.Tuple([t.Number(), t.Number()]);
+        }
+        case 'line': {
+            return t.Tuple([t.Number(), t.Number(), t.Number()]);
+        }
+        case 'vector':
+        case 'halfvector': {
+            const length = column.length;
+            const sizeParam = length
+                ? {
+                    minItems: length,
+                    maxItems: length,
+                }
+                : undefined;
+            return t.Array(t.Number(), sizeParam);
+        }
+        case 'int64vector': {
+            const length = column.length;
+            const sizeParam = length
+                ? {
+                    minItems: length,
+                    maxItems: length,
+                }
+                : undefined;
+            return t.Array(t.BigInt({
+                minimum: CONSTANTS.INT64_MIN,
+                maximum: CONSTANTS.INT64_MAX,
+            }), sizeParam);
+        }
+        case 'basecolumn': {
+            const size = column.length;
+            const sizeParam = size
+                ? {
+                    minItems: size,
+                    maxItems: size,
+                }
+                : undefined;
+            return column.baseColumn
+                ? t.Array(columnToSchema(column.baseColumn, t), sizeParam)
+                : t.Array(t.Any(), sizeParam);
+        }
+        default: {
+            return t.Array(t.Any());
+        }
+    }
 }
-function objectColumnToSchema(column, constraint, t$2) {
-	switch (constraint) {
-		case "buffer": return bufferSchema;
-		case "date": return t$2.Date();
-		case "geometry":
-		case "point": return t$2.Object({
-			x: t$2.Number(),
-			y: t$2.Number()
-		});
-		case "json": return jsonSchema;
-		case "line": return t$2.Object({
-			a: t$2.Number(),
-			b: t$2.Number(),
-			c: t$2.Number()
-		});
-		default: return t$2.Object({});
-	}
+function objectColumnToSchema(column, constraint, t) {
+    switch (constraint) {
+        case 'buffer': {
+            return bufferSchema;
+        }
+        case 'date': {
+            return t.Date();
+        }
+        case 'geometry':
+        case 'point': {
+            return t.Object({
+                x: t.Number(),
+                y: t.Number(),
+            });
+        }
+        case 'json': {
+            return jsonSchema;
+        }
+        case 'line': {
+            return t.Object({
+                a: t.Number(),
+                b: t.Number(),
+                c: t.Number(),
+            });
+        }
+        default: {
+            return t.Object({});
+        }
+    }
 }
-function bigintColumnToSchema(column, constraint, t$2) {
-	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;
-	}
-	const options = {};
-	if (min !== void 0) options.minimum = min;
-	if (max !== void 0) options.maximum = max;
-	return t$2.BigInt(Object.keys(options).length > 0 ? options : void 0);
+function bigintColumnToSchema(column, constraint, t) {
+    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;
+        }
+    }
+    const options = {};
+    if (min !== undefined) {
+        options.minimum = min;
+    }
+    if (max !== undefined) {
+        options.maximum = max;
+    }
+    return t.BigInt(Object.keys(options).length > 0 ? options : undefined);
 }
-function stringColumnToSchema(column, constraint, t$2) {
-	const { name: columnName, length, isLengthExact } = column;
-	let regex;
-	if (constraint === "binary") regex = /^[01]*$/;
-	if (constraint === "uuid") return t$2.String({ format: "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 t$2.Enum(mapEnumValues(enumValues));
-	}
-	if (constraint === "int64") return bigintStringModeSchema;
-	if (constraint === "uint64") return unsignedBigintStringModeSchema;
-	const options = {};
-	if (length !== void 0 && isLengthExact) {
-		options.minLength = length;
-		options.maxLength = length;
-	} else if (length !== void 0) options.maxLength = length;
-	return regex ? t$2.RegExp(regex, Object.keys(options).length > 0 ? options : void 0) : t$2.String(Object.keys(options).length > 0 ? options : void 0);
+function stringColumnToSchema(column, constraint, t) {
+    const { name: columnName, length, isLengthExact } = column;
+    let regex;
+    if (constraint === 'binary') {
+        regex = /^[01]*$/;
+    }
+    if (constraint === 'uuid') {
+        return t.String({
+            format: '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 t.Enum(mapEnumValues(enumValues));
+    }
+    if (constraint === 'int64') {
+        return bigintStringModeSchema;
+    }
+    if (constraint === 'uint64') {
+        return unsignedBigintStringModeSchema;
+    }
+    const options = {};
+    if (length !== undefined && isLengthExact) {
+        options.minLength = length;
+        options.maxLength = length;
+    }
+    else if (length !== undefined) {
+        options.maxLength = length;
+    }
+    return regex
+        ? t.RegExp(regex, Object.keys(options).length > 0 ? options : undefined)
+        : t.String(Object.keys(options).length > 0 ? options : undefined);
 }
 
-//#endregion
-//#region src/utils.ts
 function isColumnType(column, columnTypes) {
-	return columnTypes.includes(column.columnType);
+    return columnTypes.includes(column.columnType);
 }
 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 (0, drizzle_orm.isTable)(tableLike) ? (0, drizzle_orm.getTableColumns)(tableLike) : (0, drizzle_orm.getViewSelectedFields)(tableLike);
+    return drizzleOrm.isTable(tableLike) ? drizzleOrm.getTableColumns(tableLike) : drizzleOrm.getViewSelectedFields(tableLike);
 }
 function handleColumns(columns, refinements, conditions, factory) {
-	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?.typeboxInstance ?? _sinclair_typebox.Type) : _sinclair_typebox.Type.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] = _sinclair_typebox.Type.Union([columnSchemas[key], _sinclair_typebox.Type.Null()]);
-			if (conditions.optional(column)) columnSchemas[key] = _sinclair_typebox.Type.Optional(columnSchemas[key]);
-		}
-	}
-	return _sinclair_typebox.Type.Object(columnSchemas);
+    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?.typeboxInstance ?? typebox.Type) : typebox.Type.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] = typebox.Type.Union([columnSchemas[key], typebox.Type.Null()]);
+            }
+            if (conditions.optional(column)) {
+                columnSchemas[key] = typebox.Type.Optional(columnSchemas[key]);
+            }
+        }
+    }
+    return typebox.Type.Object(columnSchemas);
 }
 function handleEnum(enum_, factory) {
-	return (factory?.typeboxInstance ?? _sinclair_typebox.Type).Enum(mapEnumValues(enum_.enumValues));
+    const typebox$1 = factory?.typeboxInstance ?? typebox.Type;
+    return typebox$1.Enum(mapEnumValues(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);
-	return handleColumns(getColumns(entity), refine ?? {}, selectConditions);
+    if (isPgEnum(entity)) {
+        return handleEnum(entity);
+    }
+    const columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, selectConditions);
 };
 const createInsertSchema = (entity, refine) => {
-	return handleColumns(getColumns(entity), refine ?? {}, insertConditions);
+    const columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, insertConditions);
 };
 const createUpdateSchema = (entity, refine) => {
-	return handleColumns(getColumns(entity), refine ?? {}, updateConditions);
+    const columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, updateConditions);
 };
 function createSchemaFactory(options) {
-	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
-	};
+    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 };
 }
 
-//#endregion
 exports.bufferSchema = bufferSchema;
 exports.createInsertSchema = createInsertSchema;
 exports.createSchemaFactory = createSchemaFactory;
@@ -414,4 +460,4 @@ exports.isPgEnum = isPgEnum;
 exports.isWithEnum = isWithEnum;
 exports.jsonSchema = jsonSchema;
 exports.literalSchema = literalSchema;
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map