@mionjs/drizzle 0.8.0-alpha.0

package/.dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/mysql.ts';
+export * from './src/postgres.ts';
+export * from './src/sqlite.ts';

package/.dist/esm/index.js

@@ -0,0 +1,9 @@
+import { toDrizzleMySqlTable } from "./src/mysql.js";
+import { toDrizzlePGTable } from "./src/postgres.js";
+import { toDrizzleSqliteTable } from "./src/sqlite.js";
+export {
+  toDrizzleMySqlTable,
+  toDrizzlePGTable,
+  toDrizzleSqliteTable
+};
+//# sourceMappingURL=index.js.map

package/.dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/.dist/esm/src/core/typeTraverser.d.ts

@@ -0,0 +1,6 @@
+import { BaseRunType } from '@mionjs/run-types';
+import { ReflectionKind, ReceiveType } from '@deepkit/type';
+import { TypeInfo } from '../types/common.types.ts';
+export declare function extractTypeInfo<T>(type?: ReceiveType<T>): TypeInfo;
+export declare function isDateType(kind: ReflectionKind): boolean;
+export declare function getUnderlyingKind(rt: BaseRunType): ReflectionKind;

package/.dist/esm/src/core/typeTraverser.js

@@ -0,0 +1,99 @@
+import { runType, isInterfaceRunType, isPropertyRunType, isPropertySignatureRunType, getRunTypeFormat } from "@mionjs/run-types";
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+import { TypedError } from "@mionjs/core";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function extractTypeInfo(type = extractTypeInfo.Ω?.[0]) {
+  extractTypeInfo.Ω = void 0;
+  const rt = runType(type);
+  if (!isInterfaceRunType(rt)) {
+    throw new TypedError({
+      type: "drizzle-table-invalid-source-type",
+      message: `Cannot create drizzle table from type "${rt.getKindName()}". Expected an interface or object type with properties to map to table columns.`
+    });
+  }
+  const interfaceRt = rt;
+  const properties = [];
+  const children = interfaceRt.getChildRunTypes();
+  for (const child of children) {
+    if (isPropertyRunType(child) || isPropertySignatureRunType(child)) {
+      const propRt = child;
+      const memberType = propRt.getMemberType();
+      const propInfo = extractPropertyInfo(propRt, memberType);
+      properties.push(propInfo);
+    }
+  }
+  return {
+    typeName: rt.getTypeName(),
+    properties
+  };
+}
+extractTypeInfo.__type = ["ReceiveType", "type", "TypeInfo", "extractTypeInfo", 'P"w!2"8"w#/$'];
+function extractPropertyInfo(propRt, memberType) {
+  const kind = memberType.src.kind;
+  const formatInfo = getFormatInfo(memberType);
+  const isDate = checkIsDateType(memberType);
+  return {
+    name: propRt.getPropertyName(),
+    runType: memberType,
+    isOptional: propRt.isOptional(),
+    isNestedObject: isNestedObjectType(kind) && !isDate,
+    isArray: kind === ReflectionKind.array,
+    isDate,
+    formatName: formatInfo?.name,
+    formatParams: formatInfo?.params,
+    primitiveKind: isPrimitiveKind(kind) ? kind : void 0
+  };
+}
+extractPropertyInfo.__type = ["PropertyRunType", "propRt", "BaseRunType", "memberType", "PropertyInfo", "extractPropertyInfo", 'P"w!2""w#2$"w%/&'];
+function isNestedObjectType(kind) {
+  return kind === ReflectionKind.objectLiteral || kind === ReflectionKind.class;
+}
+isNestedObjectType.__type = [() => ___ReflectionKind, "kind", "isNestedObjectType", 'Pn!2")/#'];
+function isPrimitiveKind(kind) {
+  return kind === ReflectionKind.string || kind === ReflectionKind.number || kind === ReflectionKind.boolean || kind === ReflectionKind.bigint;
+}
+isPrimitiveKind.__type = [() => ___ReflectionKind, "kind", "isPrimitiveKind", 'Pn!2")/#'];
+function getFormatInfo(rt) {
+  const format = getRunTypeFormat(rt);
+  if (!format)
+    return void 0;
+  return {
+    name: format.name,
+    params: format.getParams(rt)
+  };
+}
+getFormatInfo.__type = ["BaseRunType", "rt", "name", () => __ΩRecord, "params", "getFormatInfo", 'P"w!2"PP&4#&"o$#4%M-J/&'];
+function checkIsDateType(rt) {
+  if (rt.src.kind !== ReflectionKind.class)
+    return false;
+  const src = rt.src;
+  if (src.classType === Date)
+    return true;
+  const typeName = rt.getTypeName();
+  return typeName === "Date";
+}
+checkIsDateType.__type = ["BaseRunType", "rt", "checkIsDateType", 'P"w!2")/#'];
+function isDateType(kind) {
+  return kind === ReflectionKind.class;
+}
+isDateType.__type = [() => ___ReflectionKind, "kind", "isDateType", 'Pn!2")/#'];
+function getUnderlyingKind(rt) {
+  const kind = rt.src.kind;
+  if (kind === ReflectionKind.union) {
+    const children = rt.getChildRunTypes?.() || [];
+    for (const child of children) {
+      const childKind = child.src.kind;
+      if (childKind !== ReflectionKind.null && childKind !== ReflectionKind.undefined) {
+        return childKind;
+      }
+    }
+  }
+  return kind;
+}
+getUnderlyingKind.__type = ["BaseRunType", "rt", () => ___ReflectionKind, "getUnderlyingKind", 'P"w!2"n#/$'];
+export {
+  extractTypeInfo,
+  getUnderlyingKind,
+  isDateType
+};
+//# sourceMappingURL=typeTraverser.js.map

package/.dist/esm/src/core/typeTraverser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeTraverser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/core/utils.d.ts

@@ -0,0 +1,12 @@
+import { ReflectionKind } from '@deepkit/type';
+import { PropertyInfo } from '../types/common.types.ts';
+export declare function toSnakeCase(str: string): string;
+export declare function shouldBeJson(prop: PropertyInfo): boolean;
+export declare function getParamValue<T>(param: T | {
+    val: T;
+}): T;
+export declare function isDateClass(kind: ReflectionKind, typeName?: string): boolean;
+export declare function getMaxLengthFromParams(formatParams?: Record<string, any>): number | undefined;
+export declare function getLengthFromParams(formatParams?: Record<string, any>): number | undefined;
+export declare function isIntegerFormat(formatParams?: Record<string, any>): boolean;
+export declare function isFloatFormat(formatParams?: Record<string, any>): boolean;

package/.dist/esm/src/core/utils.js

@@ -0,0 +1,62 @@
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, __assignType((letter) => `_${letter.toLowerCase()}`, ["letter", "", 'P"2!"/"']));
+}
+toSnakeCase.__type = ["str", "toSnakeCase", 'P&2!&/"'];
+function shouldBeJson(prop) {
+  return prop.isNestedObject || prop.isArray;
+}
+shouldBeJson.__type = ["PropertyInfo", "prop", "shouldBeJson", 'P"w!2")/#'];
+function getParamValue(param) {
+  if (param && typeof param === "object" && "val" in param) {
+    return param.val;
+  }
+  return param;
+}
+getParamValue.__type = ["val", "param", "getParamValue", 'PP"P"4!MJ2""/#'];
+function isDateClass(kind, typeName) {
+  return kind === ReflectionKind.class && typeName === "Date";
+}
+isDateClass.__type = [() => ___ReflectionKind, "kind", "typeName", "isDateClass", 'Pn!2"&2#8)/$'];
+function getMaxLengthFromParams(formatParams) {
+  if (!formatParams)
+    return void 0;
+  const maxLength = formatParams.maxLength;
+  return maxLength ? getParamValue(maxLength) : void 0;
+}
+getMaxLengthFromParams.__type = [() => __ΩRecord, "formatParams", "getMaxLengthFromParams", `P&"o!#2"8P'-J/#`];
+function getLengthFromParams(formatParams) {
+  if (!formatParams)
+    return void 0;
+  const length = formatParams.length;
+  return length ? getParamValue(length) : void 0;
+}
+getLengthFromParams.__type = [() => __ΩRecord, "formatParams", "getLengthFromParams", `P&"o!#2"8P'-J/#`];
+function isIntegerFormat(formatParams) {
+  if (!formatParams)
+    return false;
+  return !!getParamValue(formatParams.integer);
+}
+isIntegerFormat.__type = [() => __ΩRecord, "formatParams", "isIntegerFormat", 'P&"o!#2"8)/#'];
+function isFloatFormat(formatParams) {
+  if (!formatParams)
+    return false;
+  return !!getParamValue(formatParams.float);
+}
+isFloatFormat.__type = [() => __ΩRecord, "formatParams", "isFloatFormat", 'P&"o!#2"8)/#'];
+export {
+  getLengthFromParams,
+  getMaxLengthFromParams,
+  getParamValue,
+  isDateClass,
+  isFloatFormat,
+  isIntegerFormat,
+  shouldBeJson,
+  toSnakeCase
+};
+//# sourceMappingURL=utils.js.map

package/.dist/esm/src/core/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/core/validator.d.ts

@@ -0,0 +1,2 @@
+import { TypeInfo, ValidationResult } from '../types/common.types.ts';
+export declare function validateConfig(typeInfo: TypeInfo, tableConfig: Record<string, any>): ValidationResult;

package/.dist/esm/src/core/validator.js

@@ -0,0 +1,172 @@
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+function validateConfig(typeInfo, tableConfig) {
+  const errors = [];
+  const warnings = [];
+  for (const prop of typeInfo.properties) {
+    const configColumn = tableConfig[prop.name];
+    if (!configColumn)
+      continue;
+    const typeError = validateTypeCompatibility(prop, configColumn);
+    if (typeError)
+      errors.push(typeError);
+    const nullError = validateNullability(prop, configColumn);
+    if (nullError)
+      errors.push(nullError);
+    const formatWarning = validateFormatConstraints(prop, configColumn);
+    if (formatWarning)
+      warnings.push(formatWarning);
+  }
+  for (const configKey of Object.keys(tableConfig)) {
+    const exists = typeInfo.properties.some(__assignType((p) => p.name === configKey, ["p", "", 'P"2!"/"']));
+    if (!exists)
+      errors.push(`Column "${configKey}" exists in tableConfig but not in type "${typeInfo.typeName}"`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+validateConfig.__type = ["TypeInfo", "typeInfo", () => __ΩRecord, "tableConfig", "ValidationResult", "validateConfig", 'P"w!2"&"o##2$"w%/&'];
+function validateTypeCompatibility(prop, column) {
+  const columnType = getColumnType(column);
+  const expectedTypes = getExpectedColumnTypes(prop);
+  if (expectedTypes.length > 0 && !expectedTypes.includes(columnType)) {
+    return `Type mismatch for property "${prop.name}": TypeScript type expects ${expectedTypes.join(" or ")}, but drizzle column is "${columnType}"`;
+  }
+  return null;
+}
+validateTypeCompatibility.__type = ["PropertyInfo", "prop", "column", "validateTypeCompatibility", 'P"w!2""2#P&,J/$'];
+function validateNullability(prop, column) {
+  const isColumnNotNull = hasNotNullConstraint(column);
+  if (prop.isOptional && isColumnNotNull)
+    return `Property "${prop.name}" is optional in type but column has .notNull() constraint`;
+  return null;
+}
+validateNullability.__type = ["PropertyInfo", "prop", "column", "validateNullability", 'P"w!2""2#P&,J/$'];
+function validateFormatConstraints(prop, column) {
+  if (!prop.formatParams)
+    return null;
+  if (prop.formatParams.maxLength) {
+    const columnLength = getColumnLength(column);
+    if (columnLength && columnLength < prop.formatParams.maxLength) {
+      return `Column "${prop.name}" has length ${columnLength} but type format requires maxLength ${prop.formatParams.maxLength}`;
+    }
+  }
+  return null;
+}
+validateFormatConstraints.__type = ["PropertyInfo", "prop", "column", "validateFormatConstraints", 'P"w!2""2#P&,J/$'];
+function getColumnType(column) {
+  if (column.dataType)
+    return column.dataType;
+  if (column.columnType)
+    return column.columnType;
+  if (column._ && column._.dataType)
+    return column._.dataType;
+  if (column.config && column.config.dataType)
+    return column.config.dataType;
+  if (column.config && column.config.columnType)
+    return column.config.columnType;
+  if (column.constructor && column.constructor.name) {
+    const name = column.constructor.name;
+    if (name.includes("UUID"))
+      return "string";
+    if (name.includes("Text"))
+      return "string";
+    if (name.includes("Varchar"))
+      return "string";
+    if (name.includes("Char"))
+      return "string";
+    if (name.includes("Integer") || name.includes("Int"))
+      return "number";
+    if (name.includes("Boolean"))
+      return "boolean";
+    if (name.includes("Timestamp") || name.includes("Date"))
+      return "date";
+    if (name.includes("Json"))
+      return "json";
+    if (name.includes("Double") || name.includes("Real") || name.includes("Float"))
+      return "number";
+    if (name.includes("BigInt"))
+      return "bigint";
+  }
+  return "unknown";
+}
+getColumnType.__type = ["column", "getColumnType", 'P"2!&/"'];
+function hasNotNullConstraint(column) {
+  if (column.notNull === true)
+    return true;
+  if (column._ && column._.notNull === true)
+    return true;
+  return false;
+}
+hasNotNullConstraint.__type = ["column", "hasNotNullConstraint", 'P"2!)/"'];
+function getColumnLength(column) {
+  if (column.length)
+    return column.length;
+  if (column._ && column._.length)
+    return column._.length;
+  return null;
+}
+getColumnLength.__type = ["column", "getColumnLength", `P"2!P',J/"`];
+function getExpectedColumnTypes(prop) {
+  if (prop.isNestedObject || prop.isArray)
+    return ["json", "jsonb", "text"];
+  if (prop.formatName)
+    return getExpectedTypesForFormat(prop.formatName);
+  if (prop.primitiveKind !== void 0)
+    return getExpectedTypesForPrimitive(prop.primitiveKind);
+  const kind = prop.runType.src.kind;
+  if (kind === ReflectionKind.class) {
+    const typeName = prop.runType.getTypeName();
+    if (typeName === "Date")
+      return ["timestamp", "date", "datetime", "integer", "text"];
+  }
+  return [];
+}
+getExpectedColumnTypes.__type = ["PropertyInfo", "prop", "getExpectedColumnTypes", 'P"w!2"&F/#'];
+function getExpectedTypesForFormat(formatName) {
+  switch (formatName) {
+    case "uuid":
+      return ["uuid", "varchar", "text"];
+    case "email":
+      return ["text", "varchar"];
+    case "url":
+      return ["text", "varchar"];
+    case "ip":
+      return ["inet", "varchar", "text"];
+    case "date":
+      return ["date", "text"];
+    case "time":
+      return ["time", "text"];
+    case "dateTime":
+      return ["timestamp", "datetime", "text"];
+    case "numberFormat":
+      return ["integer", "int", "smallint", "bigint", "real", "double", "doublePrecision", "numeric", "decimal"];
+    case "bigIntFormat":
+      return ["bigint", "blob"];
+    default:
+      return [];
+  }
+}
+getExpectedTypesForFormat.__type = ["formatName", "getExpectedTypesForFormat", 'P&2!&F/"'];
+function getExpectedTypesForPrimitive(kind) {
+  switch (kind) {
+    case ReflectionKind.string:
+      return ["text", "varchar", "char", "uuid", "inet", "string"];
+    case ReflectionKind.number:
+      return ["integer", "int", "smallint", "real", "double", "doublePrecision", "numeric", "decimal", "number"];
+    case ReflectionKind.boolean:
+      return ["boolean", "integer"];
+    case ReflectionKind.bigint:
+      return ["bigint", "blob"];
+    default:
+      return [];
+  }
+}
+getExpectedTypesForPrimitive.__type = [() => ___ReflectionKind, "kind", "getExpectedTypesForPrimitive", 'Pn!2"&F/#'];
+export {
+  validateConfig
+};
+//# sourceMappingURL=validator.js.map

package/.dist/esm/src/core/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/mappers/base.mapper.d.ts

@@ -0,0 +1,14 @@
+import { ReflectionKind } from '@deepkit/type';
+import { ColumnMapping, PropertyInfo, DrizzleMapperConfig } from '../types/common.types.ts';
+import { FormatName } from '@mionjs/type-formats/constants';
+export declare abstract class BaseColumnMapper {
+    protected lengthBuffer: number;
+    constructor(config?: DrizzleMapperConfig);
+    protected applyLengthBuffer(maxLength: number): number;
+    abstract mapPrimitive(kind: ReflectionKind, propName: string): ColumnMapping;
+    abstract mapFormat(formatName: FormatName, formatParams: Record<string, any> | undefined, propName: string): ColumnMapping;
+    abstract mapArray(propName: string): ColumnMapping;
+    abstract mapObject(propName: string): ColumnMapping;
+    abstract mapDate(propName: string): ColumnMapping;
+    mapProperty(prop: PropertyInfo): ColumnMapping;
+}

package/.dist/esm/src/mappers/base.mapper.js

@@ -0,0 +1,41 @@
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+import { DEFAULT_LENGTH_BUFFER } from "../types/common.types.js";
+import { shouldBeJson } from "../core/utils.js";
+import { __ΩFormatName as ___FormatName } from "@mionjs/type-formats/constants";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+class BaseColumnMapper {
+  lengthBuffer;
+  constructor(config) {
+    this.lengthBuffer = config?.lengthBuffer ?? DEFAULT_LENGTH_BUFFER;
+  }
+  /** Applies length buffer to a maxLength value */
+  applyLengthBuffer(maxLength) {
+    return Math.ceil(maxLength * this.lengthBuffer);
+  }
+  /** Maps a property to a drizzle column based on its type information */
+  mapProperty(prop) {
+    const { name, isOptional, formatName, formatParams } = prop;
+    let mapping;
+    if (prop.isDate)
+      mapping = this.mapDate(name);
+    else if (shouldBeJson(prop)) {
+      if (prop.isArray)
+        mapping = this.mapArray(name);
+      else
+        mapping = this.mapObject(name);
+    } else if (formatName)
+      mapping = this.mapFormat(formatName, formatParams, name);
+    else if (prop.primitiveKind !== void 0)
+      mapping = this.mapPrimitive(prop.primitiveKind, name);
+    else
+      mapping = this.mapPrimitive(ReflectionKind.string, name);
+    if (!isOptional && mapping.builder.notNull)
+      mapping.builder = mapping.builder.notNull();
+    return mapping;
+  }
+  static __type = ["lengthBuffer", "DrizzleMapperConfig", "config", "constructor", "maxLength", "applyLengthBuffer", () => ___ReflectionKind, "kind", "propName", "ColumnMapping", "mapPrimitive", () => ___FormatName, "formatName", () => __ΩRecord, "formatParams", "mapFormat", "mapArray", "mapObject", "mapDate", "PropertyInfo", "prop", "mapProperty", "BaseColumnMapper", `'3!<P"w"2#8"0$P'2%'0&<Pn'2(&2)"w*0+=Pn,2-P&"o.#-J2/&2)"w*00=P&2)"w*01=P&2)"w*02=P&2)"w*03=P"w425"w*065w7`];
+}
+export {
+  BaseColumnMapper
+};
+//# sourceMappingURL=base.mapper.js.map

package/.dist/esm/src/mappers/base.mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.mapper.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/mappers/mysql.mapper.d.ts

@@ -0,0 +1,12 @@
+import { ReflectionKind } from '@deepkit/type';
+import { BaseColumnMapper } from './base.mapper.ts';
+import { ColumnMapping, DrizzleMapperConfig } from '../types/common.types.ts';
+import { FormatName } from '@mionjs/type-formats/constants';
+export declare class MySQLColumnMapper extends BaseColumnMapper {
+    constructor(config?: DrizzleMapperConfig);
+    mapPrimitive(kind: ReflectionKind, propName: string): ColumnMapping;
+    mapFormat(formatName: FormatName, formatParams: Record<string, any> | undefined, propName: string): ColumnMapping;
+    mapArray(propName: string): ColumnMapping;
+    mapObject(propName: string): ColumnMapping;
+    mapDate(propName: string): ColumnMapping;
+}

package/.dist/esm/src/mappers/mysql.mapper.js

@@ -0,0 +1,88 @@
+import { varchar, json, timestamp, bigint, boolean, double, int, time, date, datetime } from "drizzle-orm/mysql-core";
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+import { TypedError } from "@mionjs/core";
+import { BaseColumnMapper } from "./base.mapper.js";
+import { DrizzleTypesMySQL, DEFAULT_VARCHAR_LENGTH, DEFAULT_LENGTH_BUFFER } from "../types/common.types.js";
+import { getMaxLengthFromParams, isIntegerFormat } from "../core/utils.js";
+import { FormatNames, __ΩFormatName as ___FormatName } from "@mionjs/type-formats/constants";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const mysqlPrimitiveDefaults = {
+  [ReflectionKind.string]: __assignType((p) => ({
+    builder: varchar(p, { length: DEFAULT_VARCHAR_LENGTH }),
+    drizzleType: DrizzleTypesMySQL.varchar
+  }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.number]: __assignType((p) => ({ builder: double(p), drizzleType: DrizzleTypesMySQL.double }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.boolean]: __assignType((p) => ({ builder: boolean(p), drizzleType: DrizzleTypesMySQL.boolean }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.bigint]: __assignType((p) => ({ builder: bigint(p, { mode: "bigint" }), drizzleType: DrizzleTypesMySQL.bigint }), ["p", "", 'P"2!"/"'])
+};
+const mysqlFormatDefaults = {
+  [FormatNames.uuid]: __assignType((p) => ({ builder: varchar(p, { length: 36 }), drizzleType: DrizzleTypesMySQL.varchar }), ["p", "", 'P"2!"/"']),
+  [FormatNames.email]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 254;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesMySQL.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.url]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 2048;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesMySQL.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.domain]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 253;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesMySQL.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.ip]: __assignType((p) => ({ builder: varchar(p, { length: 45 }), drizzleType: DrizzleTypesMySQL.varchar }), ["p", "", 'P"2!"/"']),
+  [FormatNames.dateTime]: __assignType((p) => ({ builder: datetime(p), drizzleType: DrizzleTypesMySQL.datetime }), ["p", "", 'P"2!"/"']),
+  [FormatNames.date]: __assignType((p) => ({ builder: date(p), drizzleType: DrizzleTypesMySQL.date }), ["p", "", 'P"2!"/"']),
+  [FormatNames.time]: __assignType((p) => ({ builder: time(p), drizzleType: DrizzleTypesMySQL.time }), ["p", "", 'P"2!"/"']),
+  [FormatNames.bigintFormat]: __assignType((p) => ({ builder: bigint(p, { mode: "bigint" }), drizzleType: DrizzleTypesMySQL.bigint }), ["p", "", 'P"2!"/"']),
+  [FormatNames.numberFormat]: __assignType((p, params) => {
+    if (isIntegerFormat(params))
+      return { builder: int(p), drizzleType: DrizzleTypesMySQL.int };
+    return { builder: double(p), drizzleType: DrizzleTypesMySQL.double };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.stringFormat]: __assignType((p, params, config) => {
+    const buf = config?.lengthBuffer ?? DEFAULT_LENGTH_BUFFER;
+    const maxLength = getMaxLengthFromParams(params);
+    if (maxLength)
+      return { builder: varchar(p, { length: Math.ceil(maxLength * buf) }), drizzleType: DrizzleTypesMySQL.varchar };
+    return { builder: varchar(p, { length: DEFAULT_VARCHAR_LENGTH }), drizzleType: DrizzleTypesMySQL.varchar };
+  }, ["p", "params", "config", "", 'P"2!"2""2#"/$'])
+};
+class MySQLColumnMapper extends BaseColumnMapper {
+  constructor(config) {
+    super(config);
+  }
+  mapPrimitive(kind, propName) {
+    const factory = mysqlPrimitiveDefaults[kind];
+    if (!factory) {
+      throw new TypedError({
+        type: "drizzle-column-mapping-failed",
+        message: `Cannot map property "${propName}" to MySQL column. TypeScript primitive type "${ReflectionKind[kind]}" has no corresponding drizzle column type.`
+      });
+    }
+    return factory(propName);
+  }
+  mapFormat(formatName, formatParams, propName) {
+    const factory = mysqlFormatDefaults[formatName];
+    if (!factory)
+      return { builder: varchar(propName, { length: DEFAULT_VARCHAR_LENGTH }), drizzleType: DrizzleTypesMySQL.varchar };
+    return factory(propName, formatParams, { lengthBuffer: this.lengthBuffer });
+  }
+  mapArray(propName) {
+    return { builder: json(propName), drizzleType: DrizzleTypesMySQL.json };
+  }
+  mapObject(propName) {
+    return { builder: json(propName), drizzleType: DrizzleTypesMySQL.json };
+  }
+  mapDate(propName) {
+    return { builder: timestamp(propName), drizzleType: DrizzleTypesMySQL.timestamp };
+  }
+  static __type = [() => BaseColumnMapper, "DrizzleMapperConfig", "config", "constructor", () => ___ReflectionKind, "kind", "propName", "ColumnMapping", "mapPrimitive", () => ___FormatName, "formatName", () => __ΩRecord, "formatParams", "mapFormat", "mapArray", "mapObject", "mapDate", "MySQLColumnMapper", `P7!P"w"2#8"0$Pn%2&&2'"w(0)Pn*2+P&"o,#-J2-&2'"w(0.P&2'"w(0/P&2'"w(00P&2'"w(015w2`];
+}
+export {
+  MySQLColumnMapper
+};
+//# sourceMappingURL=mysql.mapper.js.map

package/.dist/esm/src/mappers/mysql.mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.mapper.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/mappers/pg.mapper.d.ts

@@ -0,0 +1,12 @@
+import { ReflectionKind } from '@deepkit/type';
+import { BaseColumnMapper } from './base.mapper.ts';
+import { ColumnMapping, DrizzleMapperConfig } from '../types/common.types.ts';
+import { FormatName } from '@mionjs/type-formats/constants';
+export declare class PGColumnMapper extends BaseColumnMapper {
+    constructor(config?: DrizzleMapperConfig);
+    mapPrimitive(kind: ReflectionKind, propName: string): ColumnMapping;
+    mapFormat(formatName: FormatName, formatParams: Record<string, any> | undefined, propName: string): ColumnMapping;
+    mapArray(propName: string): ColumnMapping;
+    mapObject(propName: string): ColumnMapping;
+    mapDate(propName: string): ColumnMapping;
+}