@mionjs/drizzle 0.8.0-alpha.0

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

@@ -0,0 +1,91 @@
+import { varchar, jsonb, timestamp, bigint, boolean, doublePrecision, integer, time, date, inet, uuid } from "drizzle-orm/pg-core";
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+import { TypedError } from "@mionjs/core";
+import { BaseColumnMapper } from "./base.mapper.js";
+import { DrizzleTypesPostgres, DEFAULT_VARCHAR_LENGTH, DEFAULT_LENGTH_BUFFER } from "../types/common.types.js";
+import { getMaxLengthFromParams, getLengthFromParams, 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 pgPrimitiveDefaults = {
+  [ReflectionKind.string]: __assignType((p) => ({
+    builder: varchar(p, { length: DEFAULT_VARCHAR_LENGTH }),
+    drizzleType: DrizzleTypesPostgres.varchar
+  }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.number]: __assignType((p) => ({ builder: doublePrecision(p), drizzleType: DrizzleTypesPostgres.doublePrecision }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.boolean]: __assignType((p) => ({ builder: boolean(p), drizzleType: DrizzleTypesPostgres.boolean }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.bigint]: __assignType((p) => ({ builder: bigint(p, { mode: "bigint" }), drizzleType: DrizzleTypesPostgres.bigint }), ["p", "", 'P"2!"/"'])
+};
+const pgFormatDefaults = {
+  [FormatNames.uuid]: __assignType((p) => ({ builder: uuid(p), drizzleType: DrizzleTypesPostgres.uuid }), ["p", "", 'P"2!"/"']),
+  [FormatNames.email]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 254;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesPostgres.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.url]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 2048;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesPostgres.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.domain]: __assignType((p, params) => {
+    const maxLength = getMaxLengthFromParams(params) || 253;
+    return { builder: varchar(p, { length: maxLength }), drizzleType: DrizzleTypesPostgres.varchar };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.ip]: __assignType((p) => ({ builder: inet(p), drizzleType: DrizzleTypesPostgres.inet }), ["p", "", 'P"2!"/"']),
+  [FormatNames.dateTime]: __assignType((p) => ({ builder: timestamp(p), drizzleType: DrizzleTypesPostgres.timestamp }), ["p", "", 'P"2!"/"']),
+  [FormatNames.date]: __assignType((p) => ({ builder: date(p), drizzleType: DrizzleTypesPostgres.date }), ["p", "", 'P"2!"/"']),
+  [FormatNames.time]: __assignType((p) => ({ builder: time(p), drizzleType: DrizzleTypesPostgres.time }), ["p", "", 'P"2!"/"']),
+  [FormatNames.bigintFormat]: __assignType((p) => ({ builder: bigint(p, { mode: "bigint" }), drizzleType: DrizzleTypesPostgres.bigint }), ["p", "", 'P"2!"/"']),
+  [FormatNames.numberFormat]: __assignType((p, params) => {
+    if (isIntegerFormat(params))
+      return { builder: integer(p), drizzleType: DrizzleTypesPostgres.integer };
+    return { builder: doublePrecision(p), drizzleType: DrizzleTypesPostgres.doublePrecision };
+  }, ["p", "params", "", 'P"2!"2""/#']),
+  [FormatNames.stringFormat]: __assignType((p, params, config) => {
+    const buf = config?.lengthBuffer ?? DEFAULT_LENGTH_BUFFER;
+    const maxLength = getMaxLengthFromParams(params);
+    const exactLength = getLengthFromParams(params);
+    if (exactLength)
+      return { builder: varchar(p, { length: exactLength }), drizzleType: DrizzleTypesPostgres.varchar };
+    if (maxLength)
+      return { builder: varchar(p, { length: Math.ceil(maxLength * buf) }), drizzleType: DrizzleTypesPostgres.varchar };
+    return { builder: varchar(p, { length: DEFAULT_VARCHAR_LENGTH }), drizzleType: DrizzleTypesPostgres.varchar };
+  }, ["p", "params", "config", "", 'P"2!"2""2#"/$'])
+};
+class PGColumnMapper extends BaseColumnMapper {
+  constructor(config) {
+    super(config);
+  }
+  mapPrimitive(kind, propName) {
+    const factory = pgPrimitiveDefaults[kind];
+    if (!factory) {
+      throw new TypedError({
+        type: "drizzle-column-mapping-failed",
+        message: `Cannot map property "${propName}" to PostgreSQL column. TypeScript primitive type "${ReflectionKind[kind]}" has no corresponding drizzle column type.`
+      });
+    }
+    return factory(propName);
+  }
+  mapFormat(formatName, formatParams, propName) {
+    const factory = pgFormatDefaults[formatName];
+    if (!factory)
+      return { builder: varchar(propName, { length: DEFAULT_VARCHAR_LENGTH }), drizzleType: DrizzleTypesPostgres.varchar };
+    return factory(propName, formatParams, { lengthBuffer: this.lengthBuffer });
+  }
+  mapArray(propName) {
+    return { builder: jsonb(propName), drizzleType: DrizzleTypesPostgres.jsonb };
+  }
+  mapObject(propName) {
+    return { builder: jsonb(propName), drizzleType: DrizzleTypesPostgres.jsonb };
+  }
+  mapDate(propName) {
+    return { builder: timestamp(propName), drizzleType: DrizzleTypesPostgres.timestamp };
+  }
+  static __type = [() => BaseColumnMapper, "DrizzleMapperConfig", "config", "constructor", () => ___ReflectionKind, "kind", "propName", "ColumnMapping", "mapPrimitive", () => ___FormatName, "formatName", () => __ΩRecord, "formatParams", "mapFormat", "mapArray", "mapObject", "mapDate", "PGColumnMapper", `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 {
+  PGColumnMapper
+};
+//# sourceMappingURL=pg.mapper.js.map

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

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

package/.dist/esm/src/mappers/sqlite.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 SQLiteColumnMapper 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/sqlite.mapper.js

@@ -0,0 +1,70 @@
+import { text, integer, blob, real } from "drizzle-orm/sqlite-core";
+import { ReflectionKind, __ΩReflectionKind as ___ReflectionKind } from "@deepkit/type";
+import { TypedError } from "@mionjs/core";
+import { BaseColumnMapper } from "./base.mapper.js";
+import { DrizzleTypesSQLite } from "../types/common.types.js";
+import { 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 sqlitePrimitiveDefaults = {
+  [ReflectionKind.string]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.number]: __assignType((p) => ({ builder: real(p), drizzleType: DrizzleTypesSQLite.real }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.boolean]: __assignType((p) => ({ builder: integer(p, { mode: "boolean" }), drizzleType: DrizzleTypesSQLite.integer }), ["p", "", 'P"2!"/"']),
+  [ReflectionKind.bigint]: __assignType((p) => ({ builder: blob(p, { mode: "bigint" }), drizzleType: DrizzleTypesSQLite.blob }), ["p", "", 'P"2!"/"'])
+};
+const sqliteFormatDefaults = {
+  [FormatNames.uuid]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.email]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.url]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.domain]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.ip]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.dateTime]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.date]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.time]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.stringFormat]: __assignType((p) => ({ builder: text(p), drizzleType: DrizzleTypesSQLite.text }), ["p", "", 'P"2!"/"']),
+  [FormatNames.bigintFormat]: __assignType((p) => ({ builder: blob(p, { mode: "bigint" }), drizzleType: DrizzleTypesSQLite.blob }), ["p", "", 'P"2!"/"']),
+  [FormatNames.numberFormat]: __assignType((p, params) => {
+    if (isIntegerFormat(params))
+      return { builder: integer(p), drizzleType: DrizzleTypesSQLite.integer };
+    return { builder: real(p), drizzleType: DrizzleTypesSQLite.real };
+  }, ["p", "params", "", 'P"2!"2""/#'])
+};
+class SQLiteColumnMapper extends BaseColumnMapper {
+  constructor(config) {
+    super(config);
+  }
+  mapPrimitive(kind, propName) {
+    const factory = sqlitePrimitiveDefaults[kind];
+    if (!factory) {
+      throw new TypedError({
+        type: "drizzle-column-mapping-failed",
+        message: `Cannot map property "${propName}" to SQLite column. TypeScript primitive type "${ReflectionKind[kind]}" has no corresponding drizzle column type.`
+      });
+    }
+    return factory(propName);
+  }
+  mapFormat(formatName, formatParams, propName) {
+    const factory = sqliteFormatDefaults[formatName];
+    if (!factory)
+      return { builder: text(propName), drizzleType: DrizzleTypesSQLite.text };
+    return factory(propName, formatParams, { lengthBuffer: this.lengthBuffer });
+  }
+  mapArray(propName) {
+    return { builder: text(propName, { mode: "json" }), drizzleType: DrizzleTypesSQLite.text };
+  }
+  mapObject(propName) {
+    return { builder: text(propName, { mode: "json" }), drizzleType: DrizzleTypesSQLite.text };
+  }
+  mapDate(propName) {
+    return { builder: integer(propName, { mode: "timestamp" }), drizzleType: DrizzleTypesSQLite.integer };
+  }
+  static __type = [() => BaseColumnMapper, "DrizzleMapperConfig", "config", "constructor", () => ___ReflectionKind, "kind", "propName", "ColumnMapping", "mapPrimitive", () => ___FormatName, "formatName", () => __ΩRecord, "formatParams", "mapFormat", "mapArray", "mapObject", "mapDate", "SQLiteColumnMapper", `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 {
+  SQLiteColumnMapper
+};
+//# sourceMappingURL=sqlite.mapper.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { MySqlTableWithColumns, MySqlColumnBuilderBase } from 'drizzle-orm/mysql-core';
+import { BuildColumns } from 'drizzle-orm/column-builder';
+import { ReceiveType } from '@deepkit/type';
+import { MySqlTableConfig, MySqlColumnType } from './types/mysql.types.ts';
+import { DrizzleMapperConfig, Nullable } from './types/common.types.ts';
+type MergedMySqlColumns<T, TConfig> = {
+    [K in keyof T as K extends string ? K : never]-?: K extends keyof TConfig ? TConfig[K] extends MySqlColumnBuilderBase ? TConfig[K] : Nullable<T, K, MySqlColumnType<K & string, NonNullable<T[K]>>> : Nullable<T, K, MySqlColumnType<K & string, NonNullable<T[K]>>>;
+};
+export declare function toDrizzleMySqlTable<T, TN extends string = string, TConfig extends MySqlTableConfig<T> = {}>(tableName: TN, tableConfig?: TConfig, mapperConfig?: DrizzleMapperConfig, type?: ReceiveType<T>): MySqlTableWithColumns<{
+    name: TN;
+    schema: undefined;
+    columns: BuildColumns<TN, MergedMySqlColumns<T, TConfig>, 'mysql'>;
+    dialect: 'mysql';
+}>;
+export {};

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

@@ -0,0 +1,49 @@
+import { mysqlTable } from "drizzle-orm/mysql-core";
+import { TypedError } from "@mionjs/core";
+import { extractTypeInfo } from "./core/typeTraverser.js";
+import { validateConfig } from "./core/validator.js";
+import { MySQLColumnMapper } from "./mappers/mysql.mapper.js";
+const __ΩMergedMySqlColumns = ["T", "TConfig", "Nullable", "MergedMySqlColumns", `lre*"e&!fR"w#RPe)"e%!f!qk#+QR"w#RPe#!e'"gqk/>QRe$!R!RPe#!&qkPTQRPPde$!pBPde$!pVGRb!b"Pde"!gta#w$y`];
+const DEFAULT_CONFIG = {};
+function toDrizzleMySqlTable(tableName, tableConfig, mapperConfig = DEFAULT_CONFIG, type = toDrizzleMySqlTable.Ω?.[0]) {
+  toDrizzleMySqlTable.Ω = void 0;
+  if (!type) {
+    throw new TypedError({
+      type: "drizzle-table-missing-type",
+      message: "toDrizzleMySqlTable requires a type parameter. Usage: toDrizzleMySqlTable<YourType>(tableName) or toDrizzleMySqlTable<YourType>(tableName, tableConfig)"
+    });
+  }
+  const typeInfo = (extractTypeInfo.Ω = [[type, "n!"]], extractTypeInfo(type));
+  if (tableConfig) {
+    const validation = validateConfig(typeInfo, tableConfig);
+    if (!validation.valid) {
+      throw new TypedError({
+        type: "drizzle-table-config-invalid",
+        message: `Cannot create MySQL table "${tableName}". The provided tableConfig does not match type "${typeInfo.typeName}":
+${validation.errors.join("\n")}`
+      });
+    }
+    if (validation.warnings.length > 0) {
+      console.warn(`toDrizzleMySqlTable warnings:
+${validation.warnings.join("\n")}`);
+    }
+  }
+  const mapper = new MySQLColumnMapper(mapperConfig);
+  const __ΩMerged = [() => __ΩMergedMySqlColumns, type, () => tableConfig, "Merged", 'n"Pdi#h!!qe!!!jo!#w$y'];
+  const columns = {};
+  for (const prop of typeInfo.properties) {
+    const configKey = prop.name;
+    if (tableConfig && configKey in tableConfig) {
+      columns[prop.name] = tableConfig[configKey];
+    } else {
+      const mapping = mapper.mapProperty(prop);
+      columns[prop.name] = mapping.builder;
+    }
+  }
+  return mysqlTable.Ω = [[() => tableName, "Pdi!h!!qe!!!j"], [() => __ΩMerged, "n!"]], mysqlTable(tableName, columns);
+}
+toDrizzleMySqlTable.__type = ["tableName", "tableConfig", "DrizzleMapperConfig", "mapperConfig", () => DEFAULT_CONFIG, "ReceiveType", "type", "toDrizzleMySqlTable", `P"2!"2"8"w#2$>%"w&2'8!/(`];
+export {
+  toDrizzleMySqlTable
+};
+//# sourceMappingURL=mysql.js.map

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

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

package/.dist/esm/src/postgres.d.ts

@@ -0,0 +1,15 @@
+import { PgTableWithColumns, PgColumnBuilderBase } from 'drizzle-orm/pg-core';
+import { BuildColumns } from 'drizzle-orm/column-builder';
+import { ReceiveType } from '@deepkit/type';
+import { PgTableConfig, PgColumnType } from './types/postgres.types.ts';
+import { DrizzleMapperConfig, Nullable } from './types/common.types.ts';
+type MergedPgColumns<T, TConfig> = {
+    [K in keyof T as K extends string ? K : never]-?: K extends keyof TConfig ? TConfig[K] extends PgColumnBuilderBase ? TConfig[K] : Nullable<T, K, PgColumnType<K & string, NonNullable<T[K]>>> : Nullable<T, K, PgColumnType<K & string, NonNullable<T[K]>>>;
+};
+export declare function toDrizzlePGTable<T, TN extends string = string, TConfig extends PgTableConfig<T> = {}>(tableName: TN, tableConfig?: TConfig, mapperConfig?: DrizzleMapperConfig, type?: ReceiveType<T>): PgTableWithColumns<{
+    name: TN;
+    schema: undefined;
+    columns: BuildColumns<TN, MergedPgColumns<T, TConfig>, 'pg'>;
+    dialect: 'pg';
+}>;
+export {};

package/.dist/esm/src/postgres.js

@@ -0,0 +1,49 @@
+import { pgTable } from "drizzle-orm/pg-core";
+import { TypedError } from "@mionjs/core";
+import { extractTypeInfo } from "./core/typeTraverser.js";
+import { validateConfig } from "./core/validator.js";
+import { PGColumnMapper } from "./mappers/pg.mapper.js";
+const __ΩMergedPgColumns = ["T", "TConfig", "Nullable", "MergedPgColumns", `lre*"e&!fR"w#RPe)"e%!f!qk#+QR"w#RPe#!e'"gqk/>QRe$!R!RPe#!&qkPTQRPPde$!pBPde$!pVGRb!b"Pde"!gta#w$y`];
+const DEFAULT_CONFIG = {};
+function toDrizzlePGTable(tableName, tableConfig, mapperConfig = DEFAULT_CONFIG, type = toDrizzlePGTable.Ω?.[0]) {
+  toDrizzlePGTable.Ω = void 0;
+  if (!type) {
+    throw new TypedError({
+      type: "drizzle-table-missing-type",
+      message: "toDrizzlePGTable requires a type parameter. Usage: toDrizzlePGTable<YourType>(tableName) or toDrizzlePGTable<YourType>(tableName, tableConfig)"
+    });
+  }
+  const typeInfo = (extractTypeInfo.Ω = [[type, "n!"]], extractTypeInfo(type));
+  if (tableConfig) {
+    const validation = validateConfig(typeInfo, tableConfig);
+    if (!validation.valid) {
+      throw new TypedError({
+        type: "drizzle-table-config-invalid",
+        message: `Cannot create PostgreSQL table "${tableName}". The provided tableConfig does not match type "${typeInfo.typeName}":
+${validation.errors.join("\n")}`
+      });
+    }
+    if (validation.warnings.length > 0) {
+      console.warn(`toDrizzlePGTable warnings:
+${validation.warnings.join("\n")}`);
+    }
+  }
+  const mapper = new PGColumnMapper(mapperConfig);
+  const __ΩMerged = [() => __ΩMergedPgColumns, type, () => tableConfig, "Merged", 'n"Pdi#h!!qe!!!jo!#w$y'];
+  const columns = {};
+  for (const prop of typeInfo.properties) {
+    const configKey = prop.name;
+    if (tableConfig && configKey in tableConfig) {
+      columns[prop.name] = tableConfig[configKey];
+    } else {
+      const mapping = mapper.mapProperty(prop);
+      columns[prop.name] = mapping.builder;
+    }
+  }
+  return pgTable.Ω = [[() => tableName, "Pdi!h!!qe!!!j"], [() => __ΩMerged, "n!"]], pgTable(tableName, columns);
+}
+toDrizzlePGTable.__type = ["tableName", "tableConfig", "DrizzleMapperConfig", "mapperConfig", () => DEFAULT_CONFIG, "ReceiveType", "type", "toDrizzlePGTable", `P"2!"2"8"w#2$>%"w&2'8!/(`];
+export {
+  toDrizzlePGTable
+};
+//# sourceMappingURL=postgres.js.map

package/.dist/esm/src/postgres.js.map

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

package/.dist/esm/src/sqlite.d.ts

@@ -0,0 +1,15 @@
+import { SQLiteTableWithColumns, SQLiteColumnBuilderBase } from 'drizzle-orm/sqlite-core';
+import { BuildColumns } from 'drizzle-orm/column-builder';
+import { ReceiveType } from '@deepkit/type';
+import { SqliteTableConfig, SqliteColumnType } from './types/sqlite.types.ts';
+import { DrizzleMapperConfig, Nullable } from './types/common.types.ts';
+type MergedSqliteColumns<T, TConfig> = {
+    [K in keyof T as K extends string ? K : never]-?: K extends keyof TConfig ? TConfig[K] extends SQLiteColumnBuilderBase ? TConfig[K] : Nullable<T, K, SqliteColumnType<K & string, NonNullable<T[K]>>> : Nullable<T, K, SqliteColumnType<K & string, NonNullable<T[K]>>>;
+};
+export declare function toDrizzleSqliteTable<T, TN extends string = string, TConfig extends SqliteTableConfig<T> = {}>(tableName: TN, tableConfig?: TConfig, mapperConfig?: DrizzleMapperConfig, type?: ReceiveType<T>): SQLiteTableWithColumns<{
+    name: TN;
+    schema: undefined;
+    columns: BuildColumns<TN, MergedSqliteColumns<T, TConfig>, 'sqlite'>;
+    dialect: 'sqlite';
+}>;
+export {};

package/.dist/esm/src/sqlite.js

@@ -0,0 +1,49 @@
+import { sqliteTable } from "drizzle-orm/sqlite-core";
+import { TypedError } from "@mionjs/core";
+import { extractTypeInfo } from "./core/typeTraverser.js";
+import { validateConfig } from "./core/validator.js";
+import { SQLiteColumnMapper } from "./mappers/sqlite.mapper.js";
+const __ΩMergedSqliteColumns = ["T", "TConfig", "Nullable", "MergedSqliteColumns", `lre*"e&!fR"w#RPe)"e%!f!qk#+QR"w#RPe#!e'"gqk/>QRe$!R!RPe#!&qkPTQRPPde$!pBPde$!pVGRb!b"Pde"!gta#w$y`];
+const DEFAULT_CONFIG = {};
+function toDrizzleSqliteTable(tableName, tableConfig, mapperConfig = DEFAULT_CONFIG, type = toDrizzleSqliteTable.Ω?.[0]) {
+  toDrizzleSqliteTable.Ω = void 0;
+  if (!type) {
+    throw new TypedError({
+      type: "drizzle-table-missing-type",
+      message: "toDrizzleSqliteTable requires a type parameter. Usage: toDrizzleSqliteTable<YourType>(tableName) or toDrizzleSqliteTable<YourType>(tableName, tableConfig)"
+    });
+  }
+  const typeInfo = (extractTypeInfo.Ω = [[type, "n!"]], extractTypeInfo(type));
+  if (tableConfig) {
+    const validation = validateConfig(typeInfo, tableConfig);
+    if (!validation.valid) {
+      throw new TypedError({
+        type: "drizzle-table-config-invalid",
+        message: `Cannot create SQLite table "${tableName}". The provided tableConfig does not match type "${typeInfo.typeName}":
+${validation.errors.join("\n")}`
+      });
+    }
+    if (validation.warnings.length > 0) {
+      console.warn(`toDrizzleSqliteTable warnings:
+${validation.warnings.join("\n")}`);
+    }
+  }
+  const mapper = new SQLiteColumnMapper(mapperConfig);
+  const __ΩMerged = [() => __ΩMergedSqliteColumns, type, () => tableConfig, "Merged", 'n"Pdi#h!!qe!!!jo!#w$y'];
+  const columns = {};
+  for (const prop of typeInfo.properties) {
+    const configKey = prop.name;
+    if (tableConfig && configKey in tableConfig) {
+      columns[prop.name] = tableConfig[configKey];
+    } else {
+      const mapping = mapper.mapProperty(prop);
+      columns[prop.name] = mapping.builder;
+    }
+  }
+  return sqliteTable.Ω = [[() => tableName, "Pdi!h!!qe!!!j"], [() => __ΩMerged, "n!"]], sqliteTable(tableName, columns);
+}
+toDrizzleSqliteTable.__type = ["tableName", "tableConfig", "DrizzleMapperConfig", "mapperConfig", () => DEFAULT_CONFIG, "ReceiveType", "type", "toDrizzleSqliteTable", `P"2!"2"8"w#2$>%"w&2'8!/(`];
+export {
+  toDrizzleSqliteTable
+};
+//# sourceMappingURL=sqlite.js.map

package/.dist/esm/src/sqlite.js.map

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

package/.dist/esm/src/stubs-formats-mappings/common.d.ts

@@ -0,0 +1,28 @@
+import { FormatUUIDv7, FormatEmail } from '@mionjs/type-formats/StringFormats';
+import { FormatInteger, FormatPositiveInt } from '@mionjs/type-formats/NumberFormats';
+export interface User {
+    id: FormatUUIDv7;
+    email: FormatEmail;
+    name: string;
+    age: FormatInteger;
+    score: FormatPositiveInt;
+    tags: string[];
+    profile: {
+        avatar: string;
+        theme: string;
+    };
+}
+export interface Post {
+    id: FormatUUIDv7;
+    authorId: FormatUUIDv7;
+    title: string;
+    views: FormatPositiveInt;
+}
+export interface UserWithOptional {
+    id: FormatUUIDv7;
+    name: string;
+    bio?: string;
+}
+export declare type __ΩUser = any[];
+export declare type __ΩPost = any[];
+export declare type __ΩUserWithOptional = any[];

package/.dist/esm/src/stubs-formats-mappings/common.js

@@ -0,0 +1,11 @@
+import { __ΩFormatUUIDv7 as ___FormatUUIDv7, __ΩFormatEmail as ___FormatEmail } from "@mionjs/type-formats/StringFormats";
+import { __ΩFormatPositiveInt as ___FormatPositiveInt, __ΩFormatInteger as ___FormatInteger } from "@mionjs/type-formats/NumberFormats";
+const __ΩUser = [() => ___FormatUUIDv7, "id", () => ___FormatEmail, "email", "name", () => ___FormatInteger, "age", () => ___FormatPositiveInt, "score", "tags", "avatar", "theme", "profile", "User", `Pn!4"n#4$&4%n&4'n(4)&F4*P&4+&4,M4-Mw.y`];
+const __ΩPost = [() => ___FormatUUIDv7, "id", () => ___FormatUUIDv7, "authorId", "title", () => ___FormatPositiveInt, "views", "Post", `Pn!4"n#4$&4%n&4'Mw(y`];
+const __ΩUserWithOptional = [() => ___FormatUUIDv7, "id", "name", "bio", "UserWithOptional", 'Pn!4"&4#&4$8Mw%y'];
+export {
+  __ΩPost,
+  __ΩUser,
+  __ΩUserWithOptional
+};
+//# sourceMappingURL=common.js.map

package/.dist/esm/src/stubs-formats-mappings/common.js.map

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

package/.dist/esm/src/stubs-formats-mappings/mysql.stub.d.ts

@@ -0,0 +1 @@
+export {};

package/.dist/esm/src/stubs-formats-mappings/mysql.stub.js

@@ -0,0 +1,8 @@
+import "drizzle-orm";
+import { toDrizzleMySqlTable } from "../mysql.js";
+import "@mionjs/type-formats/StringFormats";
+import { __ΩPost as ___Post, __ΩUserWithOptional as ___UserWithOptional, __ΩUser as ___User } from "./common.js";
+toDrizzleMySqlTable.Ω = [[() => ___User, "n!"]], toDrizzleMySqlTable("users");
+toDrizzleMySqlTable.Ω = [[() => ___Post, "n!"]], toDrizzleMySqlTable("posts");
+toDrizzleMySqlTable.Ω = [[() => ___UserWithOptional, "n!"]], toDrizzleMySqlTable("optional_users");
+//# sourceMappingURL=mysql.stub.js.map

package/.dist/esm/src/stubs-formats-mappings/mysql.stub.js.map

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

package/.dist/esm/src/stubs-formats-mappings/postgres.stub.d.ts

@@ -0,0 +1 @@
+export {};

package/.dist/esm/src/stubs-formats-mappings/postgres.stub.js

@@ -0,0 +1,8 @@
+import "drizzle-orm";
+import { toDrizzlePGTable } from "../postgres.js";
+import "@mionjs/type-formats/StringFormats";
+import { __ΩPost as ___Post, __ΩUserWithOptional as ___UserWithOptional, __ΩUser as ___User } from "./common.js";
+toDrizzlePGTable.Ω = [[() => ___User, "n!"]], toDrizzlePGTable("users");
+toDrizzlePGTable.Ω = [[() => ___Post, "n!"]], toDrizzlePGTable("posts");
+toDrizzlePGTable.Ω = [[() => ___UserWithOptional, "n!"]], toDrizzlePGTable("optional_users");
+//# sourceMappingURL=postgres.stub.js.map

package/.dist/esm/src/stubs-formats-mappings/postgres.stub.js.map

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

package/.dist/esm/src/stubs-formats-mappings/sqlite.stub.d.ts

@@ -0,0 +1 @@
+export {};

package/.dist/esm/src/stubs-formats-mappings/sqlite.stub.js

@@ -0,0 +1,8 @@
+import "drizzle-orm";
+import { toDrizzleSqliteTable } from "../sqlite.js";
+import "@mionjs/type-formats/StringFormats";
+import { __ΩPost as ___Post, __ΩUserWithOptional as ___UserWithOptional, __ΩUser as ___User } from "./common.js";
+toDrizzleSqliteTable.Ω = [[() => ___User, "n!"]], toDrizzleSqliteTable("users");
+toDrizzleSqliteTable.Ω = [[() => ___Post, "n!"]], toDrizzleSqliteTable("posts");
+toDrizzleSqliteTable.Ω = [[() => ___UserWithOptional, "n!"]], toDrizzleSqliteTable("optional_users");
+//# sourceMappingURL=sqlite.stub.js.map

package/.dist/esm/src/stubs-formats-mappings/sqlite.stub.js.map

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

package/.dist/esm/src/types/common.types.d.ts

@@ -0,0 +1,118 @@
+import { BaseRunType } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { BrandEmail, BrandUUID, BrandUrl, BrandDomain, BrandIP, BrandDate, BrandTime, BrandDateTime, BrandInteger, BrandFloat, BrandPositive, BrandNegative, BrandPositiveInt, BrandNegativeInt, BrandInt8, BrandInt16, BrandInt32, BrandUInt8, BrandUInt16, BrandUInt32 } from '@mionjs/core';
+export type DatabaseType = 'postgres' | 'mysql' | 'sqlite';
+type ExtractBrandName<T> = T extends {
+    brand: infer B extends string;
+} ? B : never;
+export type AllBrandNames = ExtractBrandName<BrandEmail> | ExtractBrandName<BrandUUID> | ExtractBrandName<BrandUrl> | ExtractBrandName<BrandDomain> | ExtractBrandName<BrandIP> | ExtractBrandName<BrandDate> | ExtractBrandName<BrandTime> | ExtractBrandName<BrandDateTime> | ExtractBrandName<BrandInteger> | ExtractBrandName<BrandFloat> | ExtractBrandName<BrandPositive> | ExtractBrandName<BrandNegative> | ExtractBrandName<BrandPositiveInt> | ExtractBrandName<BrandNegativeInt> | ExtractBrandName<BrandInt8> | ExtractBrandName<BrandInt16> | ExtractBrandName<BrandInt32> | ExtractBrandName<BrandUInt8> | ExtractBrandName<BrandUInt16> | ExtractBrandName<BrandUInt32>;
+export declare const DrizzleTypesPostgres: {
+    readonly text: "text";
+    readonly boolean: "boolean";
+    readonly bigint: "bigint";
+    readonly varchar: "varchar";
+    readonly date: "date";
+    readonly time: "time";
+    readonly timestamp: "timestamp";
+    readonly integer: "integer";
+    readonly doublePrecision: "doublePrecision";
+    readonly uuid: "uuid";
+    readonly inet: "inet";
+    readonly char: "char";
+    readonly jsonb: "jsonb";
+};
+export declare const DrizzleTypesMySQL: {
+    readonly text: "text";
+    readonly boolean: "boolean";
+    readonly bigint: "bigint";
+    readonly varchar: "varchar";
+    readonly date: "date";
+    readonly time: "time";
+    readonly timestamp: "timestamp";
+    readonly json: "json";
+    readonly double: "double";
+    readonly int: "int";
+    readonly datetime: "datetime";
+};
+export declare const DrizzleTypesSQLite: {
+    readonly text: "text";
+    readonly integer: "integer";
+    readonly real: "real";
+    readonly blob: "blob";
+};
+export declare const DrizzleTypes: {
+    readonly text: "text";
+    readonly integer: "integer";
+    readonly real: "real";
+    readonly blob: "blob";
+    readonly boolean: "boolean";
+    readonly bigint: "bigint";
+    readonly varchar: "varchar";
+    readonly date: "date";
+    readonly time: "time";
+    readonly timestamp: "timestamp";
+    readonly json: "json";
+    readonly double: "double";
+    readonly int: "int";
+    readonly datetime: "datetime";
+    readonly doublePrecision: "doublePrecision";
+    readonly uuid: "uuid";
+    readonly inet: "inet";
+    readonly char: "char";
+    readonly jsonb: "jsonb";
+};
+export type DrizzleTypePostgres = (typeof DrizzleTypesPostgres)[keyof typeof DrizzleTypesPostgres];
+export type DrizzleTypeMySQL = (typeof DrizzleTypesMySQL)[keyof typeof DrizzleTypesMySQL];
+export type DrizzleTypeSQLite = (typeof DrizzleTypesSQLite)[keyof typeof DrizzleTypesSQLite];
+export type DrizzleType = (typeof DrizzleTypes)[keyof typeof DrizzleTypes];
+export interface ColumnMapping {
+    builder: any;
+    drizzleType: DrizzleType;
+}
+export type PrimitiveColumnFactory = (propName: string) => ColumnMapping;
+export type FormatColumnFactory = (propName: string, formatParams?: Record<string, any>, config?: DrizzleMapperConfig) => ColumnMapping;
+export interface PropertyInfo {
+    name: string;
+    runType: BaseRunType;
+    isOptional: boolean;
+    isNestedObject: boolean;
+    isArray: boolean;
+    isDate: boolean;
+    formatName?: string;
+    formatParams?: Record<string, any>;
+    primitiveKind?: ReflectionKind;
+}
+export interface TypeInfo {
+    typeName: string;
+    properties: PropertyInfo[];
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare const DEFAULT_VARCHAR_LENGTH = 255;
+export declare const DEFAULT_LENGTH_BUFFER = 1.5;
+export interface DrizzleMapperConfig {
+    lengthBuffer?: number;
+}
+export type Nullable<T, K extends keyof T, Col> = {} extends Pick<T, K> ? Col : Col & {
+    _: {
+        notNull: true;
+    };
+};
+export {};
+export declare type __ΩDatabaseType = any[];
+export declare type __ΩAllBrandNames = any[];
+export declare type __ΩDrizzleTypePostgres = any[];
+export declare type __ΩDrizzleTypeMySQL = any[];
+export declare type __ΩDrizzleTypeSQLite = any[];
+export declare type __ΩDrizzleType = any[];
+export declare type __ΩColumnMapping = any[];
+export declare type __ΩPrimitiveColumnFactory = any[];
+export declare type __ΩFormatColumnFactory = any[];
+export declare type __ΩPropertyInfo = any[];
+export declare type __ΩTypeInfo = any[];
+export declare type __ΩValidationResult = any[];
+export declare type __ΩDrizzleMapperConfig = any[];
+export declare type __ΩNullable = any[];