drizzle-typebox 0.3.3 → 1.0.0-beta.10-b5fdd85

package/index.cjs

@@ -1,345 +1,406 @@
-'use strict';
-
-var typebox = require('@sinclair/typebox');
-var drizzleOrm = require('drizzle-orm');
+let _sinclair_typebox = require("@sinclair/typebox");
+let drizzle_orm = 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: -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
 };
 
-function isColumnType(column, columnTypes) {
-    return columnTypes.includes(column.columnType);
+//#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"
+};
+function mapEnumValues(values) {
+	return Object.fromEntries(values.map((value) => [value, value]));
 }
-function isWithEnum(column) {
-    return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
+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;
 }
-const isPgEnum = isWithEnum;
-
-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); // eslint-disable-line no-instanceof/no-instanceof
-const bufferSchema = { [typebox.Kind]: 'Buffer', type: 'buffer' };
-function mapEnumValues(values) {
-    return Object.fromEntries(values.map((value) => [value, value]));
+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 columnToSchema(column, t) {
-    let schema;
-    if (isWithEnum(column)) {
-        schema = column.enumValues.length ? t.Enum(mapEnumValues(column.enumValues)) : t.String();
-    }
-    if (!schema) {
-        // Handle specific types
-        if (isColumnType(column, ['PgGeometry', 'PgPointTuple'])) {
-            schema = t.Tuple([t.Number(), t.Number()]);
-        }
-        else if (isColumnType(column, ['PgGeometryObject', 'PgPointObject'])) {
-            schema = t.Object({ x: t.Number(), y: t.Number() });
-        }
-        else if (isColumnType(column, ['PgHalfVector', 'PgVector'])) {
-            schema = t.Array(t.Number(), column.dimensions
-                ? {
-                    minItems: column.dimensions,
-                    maxItems: column.dimensions,
-                }
-                : undefined);
-        }
-        else if (isColumnType(column, ['PgLine'])) {
-            schema = t.Tuple([t.Number(), t.Number(), t.Number()]);
-        }
-        else if (isColumnType(column, ['PgLineABC'])) {
-            schema = t.Object({
-                a: t.Number(),
-                b: t.Number(),
-                c: t.Number(),
-            });
-        } // Handle other types
-        else if (isColumnType(column, ['PgArray'])) {
-            schema = t.Array(columnToSchema(column.baseColumn, t), column.size
-                ? {
-                    minItems: column.size,
-                    maxItems: column.size,
-                }
-                : undefined);
-        }
-        else if (column.dataType === 'array') {
-            schema = t.Array(t.Any());
-        }
-        else if (column.dataType === 'number') {
-            schema = numberColumnToSchema(column, t);
-        }
-        else if (column.dataType === 'bigint') {
-            schema = bigintColumnToSchema(column, t);
-        }
-        else if (column.dataType === 'boolean') {
-            schema = t.Boolean();
-        }
-        else if (column.dataType === 'date') {
-            schema = t.Date();
-        }
-        else if (column.dataType === 'string') {
-            schema = stringColumnToSchema(column, t);
-        }
-        else if (column.dataType === 'json') {
-            schema = jsonSchema;
-        }
-        else if (column.dataType === 'custom') {
-            schema = t.Any();
-        }
-        else if (column.dataType === 'buffer') {
-            schema = bufferSchema;
-        }
-    }
-    if (!schema) {
-        schema = t.Any();
-    }
-    return schema;
+_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;
+});
+_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;
+});
+/** @internal */
+const bigintStringModeSchema = {
+	[_sinclair_typebox.Kind]: "BigIntStringMode",
+	type: "string"
+};
+/** @internal */
+const unsignedBigintStringModeSchema = {
+	[_sinclair_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 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 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 numberColumnToSchema(column, t) {
-    let unsigned = column.getSQLType().includes('unsigned');
-    let min;
-    let max;
-    let integer = false;
-    if (isColumnType(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
-        min = unsigned ? 0 : CONSTANTS.INT8_MIN;
-        max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
-        integer = true;
-    }
-    else if (isColumnType(column, [
-        'PgSmallInt',
-        'PgSmallSerial',
-        'MySqlSmallInt',
-        'SingleStoreSmallInt',
-    ])) {
-        min = unsigned ? 0 : CONSTANTS.INT16_MIN;
-        max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
-        integer = true;
-    }
-    else if (isColumnType(column, [
-        'PgReal',
-        'MySqlFloat',
-        'MySqlMediumInt',
-        'SingleStoreFloat',
-        'SingleStoreMediumInt',
-    ])) {
-        min = unsigned ? 0 : CONSTANTS.INT24_MIN;
-        max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
-        integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
-    }
-    else if (isColumnType(column, [
-        'PgInteger',
-        'PgSerial',
-        'MySqlInt',
-        'SingleStoreInt',
-    ])) {
-        min = unsigned ? 0 : CONSTANTS.INT32_MIN;
-        max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
-        integer = true;
-    }
-    else if (isColumnType(column, [
-        'PgDoublePrecision',
-        'MySqlReal',
-        'MySqlDouble',
-        'SingleStoreReal',
-        'SingleStoreDouble',
-        'SQLiteReal',
-    ])) {
-        min = unsigned ? 0 : CONSTANTS.INT48_MIN;
-        max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
-    }
-    else if (isColumnType(column, [
-        'PgBigInt53',
-        'PgBigSerial53',
-        'MySqlBigInt53',
-        'MySqlSerial',
-        'SingleStoreBigInt53',
-        'SingleStoreSerial',
-        'SQLiteInteger',
-    ])) {
-        unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
-        min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
-        max = Number.MAX_SAFE_INTEGER;
-        integer = true;
-    }
-    else if (isColumnType(column, ['MySqlYear', 'SingleStoreYear'])) {
-        min = 1901;
-        max = 2155;
-        integer = true;
-    }
-    else {
-        min = Number.MIN_SAFE_INTEGER;
-        max = Number.MAX_SAFE_INTEGER;
-    }
-    const key = integer ? 'Integer' : 'Number';
-    return t[key]({
-        minimum: min,
-        maximum: max,
-    });
+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 bigintColumnToSchema(column, t) {
-    const unsigned = column.getSQLType().includes('unsigned');
-    const min = unsigned ? 0n : CONSTANTS.INT64_MIN;
-    const max = unsigned ? CONSTANTS.INT64_UNSIGNED_MAX : CONSTANTS.INT64_MAX;
-    return t.BigInt({
-        minimum: min,
-        maximum: max,
-    });
+
+//#endregion
+//#region src/utils.ts
+function isColumnType(column, columnTypes) {
+	return columnTypes.includes(column.columnType);
 }
-function stringColumnToSchema(column, t) {
-    if (isColumnType(column, ['PgUUID'])) {
-        return t.String({ format: 'uuid' });
-    }
-    else if (isColumnType(column, [
-        'PgBinaryVector',
-    ])) {
-        return t.RegExp(/^[01]+$/, column.dimensions ? { maxLength: column.dimensions } : undefined);
-    }
-    let max;
-    let fixed = false;
-    if (isColumnType(column, ['PgVarchar', 'SQLiteText'])) {
-        max = column.length;
-    }
-    else if (isColumnType(column, ['MySqlVarChar', 'SingleStoreVarChar'])) {
-        max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
-    }
-    else if (isColumnType(column, ['MySqlText', 'SingleStoreText'])) {
-        if (column.textType === 'longtext') {
-            max = CONSTANTS.INT32_UNSIGNED_MAX;
-        }
-        else if (column.textType === 'mediumtext') {
-            max = CONSTANTS.INT24_UNSIGNED_MAX;
-        }
-        else if (column.textType === 'text') {
-            max = CONSTANTS.INT16_UNSIGNED_MAX;
-        }
-        else {
-            max = CONSTANTS.INT8_UNSIGNED_MAX;
-        }
-    }
-    if (isColumnType(column, [
-        'PgChar',
-        'MySqlChar',
-        'SingleStoreChar',
-    ])) {
-        max = column.length;
-        fixed = true;
-    }
-    const options = {};
-    if (max !== undefined && fixed) {
-        options.minLength = max;
-        options.maxLength = max;
-    }
-    else if (max !== undefined) {
-        options.maxLength = max;
-    }
-    return t.String(Object.keys(options).length > 0 ? options : undefined);
+function isWithEnum(column) {
+	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?.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);
+	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);
 }
 function handleEnum(enum_, factory) {
-    const typebox$1 = factory?.typeboxInstance ?? typebox.Type;
-    return typebox$1.Enum(mapEnumValues(enum_.enumValues));
+	return (factory?.typeboxInstance ?? _sinclair_typebox.Type).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',
-    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',
-    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;
@@ -353,4 +414,4 @@ exports.isPgEnum = isPgEnum;
 exports.isWithEnum = isWithEnum;
 exports.jsonSchema = jsonSchema;
 exports.literalSchema = literalSchema;
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map