drizzle-arktype 1.0.0-beta.6-051f3cd → 1.0.0-beta.6-a42e15a

package/index.mjs

@@ -1,333 +1,387 @@
-import { type } from "arktype";
-import { Column, SQL, extractExtendedColumnType, getColumnTable, getTableColumns, getTableName, getViewSelectedFields, is, isTable, isView } from "drizzle-orm";
+import { type } from 'arktype';
+import { extractExtendedColumnType, getTableName, getColumnTable, isTable, getTableColumns, getViewSelectedFields, is, Column, SQL, isView } from '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 = type.string.or(type.number).or(type.boolean).or(type.null);
 const jsonSchema = literalSchema.or(type.unknown.as().array()).or(type.object.as());
-const bufferSchema = type.unknown.narrow((value) => value instanceof Buffer).as().describe("a Buffer instance");
+const bufferSchema = type.unknown.narrow((value) => value instanceof Buffer).as().describe('a Buffer instance');
 function columnToSchema(column) {
-	let schema;
-	const dimensions = column.dimensions;
-	if (typeof dimensions === "number" && dimensions > 0) return pgArrayColumnToSchema(column, dimensions);
-	const { type: columnType, constraint } = extractExtendedColumnType(column);
-	switch (columnType) {
-		case "array":
-			schema = arrayColumnToSchema(column, constraint);
-			break;
-		case "object":
-			schema = objectColumnToSchema(column, constraint);
-			break;
-		case "number":
-			schema = numberColumnToSchema(column, constraint);
-			break;
-		case "bigint":
-			schema = bigintColumnToSchema(column, constraint);
-			break;
-		case "boolean":
-			schema = type.boolean;
-			break;
-		case "string":
-			schema = stringColumnToSchema(column, constraint);
-			break;
-		case "custom":
-			schema = type.unknown;
-			break;
-		default: schema = type.unknown;
-	}
-	return schema;
+    let schema;
+    const { type: columnType, constraint } = extractExtendedColumnType(column);
+    switch (columnType) {
+        case 'array': {
+            schema = arrayColumnToSchema(column, constraint);
+            break;
+        }
+        case 'object': {
+            schema = objectColumnToSchema(column, constraint);
+            break;
+        }
+        case 'number': {
+            schema = numberColumnToSchema(column, constraint);
+            break;
+        }
+        case 'bigint': {
+            schema = bigintColumnToSchema(column, constraint);
+            break;
+        }
+        case 'boolean': {
+            schema = type.boolean;
+            break;
+        }
+        case 'string': {
+            schema = stringColumnToSchema(column, constraint);
+            break;
+        }
+        case 'custom': {
+            schema = type.unknown;
+            break;
+        }
+        default: {
+            schema = type.unknown;
+        }
+    }
+    return schema;
 }
 function numberColumnToSchema(column, constraint) {
-	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 (integer ? type.keywords.number.integer : type.number).atLeast(min).atMost(max);
-}
-function pgArrayColumnToSchema(column, dimensions) {
-	const [baseType, baseConstraint] = column.dataType.split(" ");
-	let baseSchema;
-	switch (baseType) {
-		case "number":
-			baseSchema = numberColumnToSchema(column, baseConstraint);
-			break;
-		case "bigint":
-			baseSchema = bigintColumnToSchema(column, baseConstraint);
-			break;
-		case "boolean":
-			baseSchema = type.boolean;
-			break;
-		case "string":
-			baseSchema = stringColumnToSchema(column, baseConstraint);
-			break;
-		case "object":
-			baseSchema = objectColumnToSchema(column, baseConstraint);
-			break;
-		case "array":
-			baseSchema = arrayColumnToSchema(column, baseConstraint);
-			break;
-		default: baseSchema = type.unknown;
-	}
-	let schema = baseSchema.array();
-	for (let i = 1; i < dimensions; i++) schema = schema.array();
-	return schema;
+    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 (integer ? type.keywords.number.integer : type.number).atLeast(min).atMost(max);
 }
 function arrayColumnToSchema(column, constraint) {
-	switch (constraint) {
-		case "geometry":
-		case "point": return type([type.number, type.number]);
-		case "line": return type([
-			type.number,
-			type.number,
-			type.number
-		]);
-		case "vector":
-		case "halfvector": {
-			const length = column.length;
-			return length ? type.number.array().exactlyLength(length) : type.number.array();
-		}
-		case "int64vector": {
-			const length = column.length;
-			return length ? type.bigint.array().exactlyLength(length) : type.bigint.array();
-		}
-		case "basecolumn": {
-			const baseColumn = column.baseColumn;
-			if (baseColumn) {
-				const length = column.length;
-				const schema = columnToSchema(baseColumn).array();
-				if (length) return schema.exactlyLength(length);
-				return schema;
-			}
-			return type.unknown.array();
-		}
-		default: return type.unknown.array();
-	}
+    switch (constraint) {
+        case 'geometry':
+        case 'point': {
+            return type([type.number, type.number]);
+        }
+        case 'line': {
+            return type([type.number, type.number, type.number]);
+        }
+        case 'vector':
+        case 'halfvector': {
+            const length = column.length;
+            return length ? type.number.array().exactlyLength(length) : type.number.array();
+        }
+        case 'int64vector': {
+            const length = column.length;
+            // TODO - INT64 number range
+            return length ? type.bigint.array().exactlyLength(length) : type.bigint.array();
+        }
+        case 'basecolumn': {
+            const length = column.length;
+            const schema = column.baseColumn
+                ? columnToSchema(column.baseColumn).array()
+                : type.unknown.array();
+            if (length)
+                return schema.exactlyLength(length);
+            return schema;
+        }
+        default: {
+            return type.unknown.array();
+        }
+    }
 }
 function objectColumnToSchema(column, constraint) {
-	switch (constraint) {
-		case "buffer": return bufferSchema;
-		case "date": return type.Date;
-		case "geometry":
-		case "point": return type({
-			x: type.number,
-			y: type.number
-		});
-		case "json": return jsonSchema;
-		case "line": return type({
-			a: type.number,
-			b: type.number,
-			c: type.number
-		});
-		default: return type({});
-	}
+    switch (constraint) {
+        case 'buffer': {
+            return bufferSchema;
+        }
+        case 'date': {
+            return type.Date;
+        }
+        case 'geometry':
+        case 'point': {
+            return type({
+                x: type.number,
+                y: type.number,
+            });
+        }
+        case 'json': {
+            return jsonSchema;
+        }
+        case 'line': {
+            return type({
+                a: type.number,
+                b: type.number,
+                c: type.number,
+            });
+        }
+        default: {
+            return type({});
+        }
+    }
 }
 /** @internal */
-const unsignedBigintNarrow = (v, ctx) => v < 0n ? ctx.mustBe("greater than") : v > CONSTANTS.INT64_UNSIGNED_MAX ? ctx.mustBe("less than") : true;
+const unsignedBigintNarrow = (v, ctx) => v < 0n ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_UNSIGNED_MAX ? ctx.mustBe('less than') : true;
 /** @internal */
-const bigintNarrow = (v, ctx) => v < CONSTANTS.INT64_MIN ? ctx.mustBe("greater than") : v > CONSTANTS.INT64_MAX ? ctx.mustBe("less than") : true;
+const bigintNarrow = (v, ctx) => v < CONSTANTS.INT64_MIN ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_MAX ? ctx.mustBe('less than') : true;
 /** @internal */
 const bigintStringModeSchema = type.string.narrow((v, ctx) => {
-	if (typeof v !== "string") return ctx.mustBe("a string");
-	if (!/^-?\d+$/.test(v)) return ctx.mustBe("a string representing a number");
-	const bigint = BigInt(v);
-	if (bigint < CONSTANTS.INT64_MIN) return ctx.mustBe("greater than");
-	if (bigint > CONSTANTS.INT64_MAX) return ctx.mustBe("less than");
-	return true;
+    if (typeof v !== 'string') {
+        return ctx.mustBe('a string');
+    }
+    if (!(/^-?\d+$/.test(v))) {
+        return ctx.mustBe('a string representing a number');
+    }
+    const bigint = BigInt(v);
+    if (bigint < CONSTANTS.INT64_MIN) {
+        return ctx.mustBe('greater than');
+    }
+    if (bigint > CONSTANTS.INT64_MAX) {
+        return ctx.mustBe('less than');
+    }
+    return true;
 });
 /** @internal */
 const unsignedBigintStringModeSchema = type.string.narrow((v, ctx) => {
-	if (typeof v !== "string") return ctx.mustBe("a string");
-	if (!/^\d+$/.test(v)) return ctx.mustBe("a string representing a number");
-	const bigint = BigInt(v);
-	if (bigint < 0) return ctx.mustBe("greater than");
-	if (bigint > CONSTANTS.INT64_MAX) return ctx.mustBe("less than");
-	return true;
+    if (typeof v !== 'string') {
+        return ctx.mustBe('a string');
+    }
+    if (!(/^\d+$/.test(v))) {
+        return ctx.mustBe('a string representing a number');
+    }
+    const bigint = BigInt(v);
+    if (bigint < 0) {
+        return ctx.mustBe('greater than');
+    }
+    if (bigint > CONSTANTS.INT64_MAX) {
+        return ctx.mustBe('less than');
+    }
+    return true;
 });
 function bigintColumnToSchema(column, constraint) {
-	switch (constraint) {
-		case "int64": return type.bigint.narrow(bigintNarrow);
-		case "uint64": return type.bigint.narrow(unsignedBigintNarrow);
-	}
-	return type.bigint;
+    switch (constraint) {
+        case 'int64': {
+            return type.bigint.narrow(bigintNarrow);
+        }
+        case 'uint64': {
+            return type.bigint.narrow(unsignedBigintNarrow);
+        }
+    }
+    return type.bigint;
 }
 function stringColumnToSchema(column, constraint) {
-	const { name: columnName, length, isLengthExact } = column;
-	if (constraint === "binary") return type(`/^[01]${length ? `{${isLengthExact ? length : `0,${length}`}}` : "*"}$/`).describe(`a string containing ones or zeros${length ? ` while being ${isLengthExact ? "" : "up to "}${length} characters long` : ""}`);
-	if (constraint === "uuid") return type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe("a RFC-4122-compliant UUID");
-	if (constraint === "enum") {
-		const enumValues = column.enumValues;
-		if (!enumValues) throw new Error(`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`);
-		return type.enumerated(...enumValues);
-	}
-	if (constraint === "int64") return bigintStringModeSchema;
-	if (constraint === "uint64") return unsignedBigintStringModeSchema;
-	return length && isLengthExact ? type.string.exactlyLength(length) : length ? type.string.atMostLength(length) : type.string;
+    const { name: columnName, length, isLengthExact } = column;
+    if (constraint === 'binary') {
+        return type(`/^[01]${length ? `{${isLengthExact ? length : `0,${length}`}}` : '*'}$/`)
+            .describe(`a string containing ones or zeros${length ? ` while being ${isLengthExact ? '' : 'up to '}${length} characters long` : ''}`);
+    }
+    if (constraint === 'uuid') {
+        return type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID');
+    }
+    if (constraint === 'enum') {
+        const enumValues = column.enumValues;
+        if (!enumValues) {
+            throw new Error(`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`);
+        }
+        return type.enumerated(...enumValues);
+    }
+    if (constraint === 'int64') {
+        return bigintStringModeSchema;
+    }
+    if (constraint === 'uint64') {
+        return unsignedBigintStringModeSchema;
+    }
+    return length && isLengthExact
+        ? type.string.exactlyLength(length)
+        : length
+            ? type.string.atMostLength(length)
+            : type.string;
 }
 
-//#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 isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
+    return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
 }
 function handleColumns(columns, refinements, conditions) {
-	const columnSchemas = {};
-	for (const [key, selected] of Object.entries(columns)) {
-		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === "object") {
-			columnSchemas[key] = handleColumns(isTable(selected) || isView(selected) ? getColumns(selected) : selected, refinements[key] ?? {}, conditions);
-			continue;
-		}
-		const refinement = refinements[key];
-		if (refinement !== void 0 && (typeof refinement !== "function" || typeof refinement === "function" && refinement.expression !== void 0)) {
-			columnSchemas[key] = refinement;
-			continue;
-		}
-		const column = is(selected, Column) ? selected : void 0;
-		const schema = column ? columnToSchema(column) : type.unknown;
-		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].or(type.null);
-			if (conditions.optional(column)) columnSchemas[key] = columnSchemas[key].optional();
-		}
-	}
-	return type(columnSchemas);
+    const columnSchemas = {};
+    for (const [key, selected] of Object.entries(columns)) {
+        if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+            const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+            columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
+            continue;
+        }
+        const refinement = refinements[key];
+        if (refinement !== undefined
+            && (typeof refinement !== 'function' || (typeof refinement === 'function' && refinement.expression !== undefined))) {
+            columnSchemas[key] = refinement;
+            continue;
+        }
+        const column = is(selected, Column) ? selected : undefined;
+        const schema = column ? columnToSchema(column) : type.unknown;
+        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].or(type.null);
+            }
+            if (conditions.optional(column)) {
+                columnSchemas[key] = columnSchemas[key].optional();
+            }
+        }
+    }
+    return type(columnSchemas);
 }
 const createSelectSchema = ((entity, refine) => {
-	if (isPgEnum(entity)) return type.enumerated(...entity.enumValues);
-	return handleColumns(getColumns(entity), refine ?? {}, {
-		never: () => false,
-		optional: () => false,
-		nullable: (column) => !column.notNull
-	});
+    if (isPgEnum(entity)) {
+        return type.enumerated(...entity.enumValues);
+    }
+    const columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, {
+        never: () => false,
+        optional: () => false,
+        nullable: (column) => !column.notNull,
+    });
 });
 const createInsertSchema = ((entity, refine) => {
-	return handleColumns(getColumns(entity), refine ?? {}, {
-		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 columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, {
+        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 createUpdateSchema = ((entity, refine) => {
-	return handleColumns(getColumns(entity), refine ?? {}, {
-		never: (column) => column?.generated?.type === "always" || column?.generatedIdentity?.type === "always" || "identity" in (column ?? {}) && typeof column?.identity !== "undefined",
-		optional: () => true,
-		nullable: (column) => !column.notNull
-	});
+    const columns = getColumns(entity);
+    return handleColumns(columns, refine ?? {}, {
+        never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+            || ('identity' in (column ?? {}) && typeof column?.identity !== 'undefined'),
+        optional: () => true,
+        nullable: (column) => !column.notNull,
+    });
 });
 
-//#endregion
 export { bufferSchema, createInsertSchema, createSelectSchema, createUpdateSchema, isColumnType, isPgEnum, isWithEnum, jsonSchema, literalSchema };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map