drizzle-orm 0.28.3 → 0.28.4

package/sqlite-core/columns/blob.d.cts

@@ -0,0 +1,65 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="bun-types" />
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
+type BlobMode = 'buffer' | 'json' | 'bigint';
+export type SQLiteBigIntBuilderInitial<TName extends string> = SQLiteBigIntBuilder<{
+    name: TName;
+    dataType: 'bigint';
+    columnType: 'SQLiteBigInt';
+    data: bigint;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'SQLiteBigInt'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBigInt<T extends ColumnBaseConfig<'bigint', 'SQLiteBigInt'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: Buffer): bigint;
+    mapToDriverValue(value: bigint): Buffer;
+}
+export type SQLiteBlobJsonBuilderInitial<TName extends string> = SQLiteBlobJsonBuilder<{
+    name: TName;
+    dataType: 'json';
+    columnType: 'SQLiteBlobJson';
+    data: unknown;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBlobJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SQLiteBlobJson'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBlobJson<T extends ColumnBaseConfig<'json', 'SQLiteBlobJson'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: Buffer): T['data'];
+    mapToDriverValue(value: T['data']): Buffer;
+}
+export type SQLiteBlobBufferBuilderInitial<TName extends string> = SQLiteBlobBufferBuilder<{
+    name: TName;
+    dataType: 'buffer';
+    columnType: 'SQLiteBlobBuffer';
+    data: Buffer;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBlobBufferBuilder<T extends ColumnBuilderBaseConfig<'buffer', 'SQLiteBlobBuffer'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBlobBuffer<T extends ColumnBaseConfig<'buffer', 'SQLiteBlobBuffer'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export interface BlobConfig<TMode extends BlobMode = BlobMode> {
+    mode: TMode;
+}
+export declare function blob<TName extends string, TMode extends BlobMode = BlobMode>(name: TName, config?: BlobConfig<TMode>): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilderInitial<TName> : Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilderInitial<TName> : SQLiteBlobJsonBuilderInitial<TName>;
+export {};

package/sqlite-core/columns/blob.d.mts

@@ -0,0 +1,65 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="bun-types" />
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
+type BlobMode = 'buffer' | 'json' | 'bigint';
+export type SQLiteBigIntBuilderInitial<TName extends string> = SQLiteBigIntBuilder<{
+    name: TName;
+    dataType: 'bigint';
+    columnType: 'SQLiteBigInt';
+    data: bigint;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'SQLiteBigInt'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBigInt<T extends ColumnBaseConfig<'bigint', 'SQLiteBigInt'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: Buffer): bigint;
+    mapToDriverValue(value: bigint): Buffer;
+}
+export type SQLiteBlobJsonBuilderInitial<TName extends string> = SQLiteBlobJsonBuilder<{
+    name: TName;
+    dataType: 'json';
+    columnType: 'SQLiteBlobJson';
+    data: unknown;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBlobJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SQLiteBlobJson'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBlobJson<T extends ColumnBaseConfig<'json', 'SQLiteBlobJson'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: Buffer): T['data'];
+    mapToDriverValue(value: T['data']): Buffer;
+}
+export type SQLiteBlobBufferBuilderInitial<TName extends string> = SQLiteBlobBufferBuilder<{
+    name: TName;
+    dataType: 'buffer';
+    columnType: 'SQLiteBlobBuffer';
+    data: Buffer;
+    driverParam: Buffer;
+    enumValues: undefined;
+}>;
+export declare class SQLiteBlobBufferBuilder<T extends ColumnBuilderBaseConfig<'buffer', 'SQLiteBlobBuffer'>> extends SQLiteColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class SQLiteBlobBuffer<T extends ColumnBaseConfig<'buffer', 'SQLiteBlobBuffer'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export interface BlobConfig<TMode extends BlobMode = BlobMode> {
+    mode: TMode;
+}
+export declare function blob<TName extends string, TMode extends BlobMode = BlobMode>(name: TName, config?: BlobConfig<TMode>): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilderInitial<TName> : Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilderInitial<TName> : SQLiteBlobJsonBuilderInitial<TName>;
+export {};

package/sqlite-core/columns/blob.d.ts

@@ -1,10 +1,10 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 /// <reference types="bun-types" />
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import { type Equal } from '../../utils';
-import { SQLiteColumn, SQLiteColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
 type BlobMode = 'buffer' | 'json' | 'bigint';
 export type SQLiteBigIntBuilderInitial<TName extends string> = SQLiteBigIntBuilder<{
     name: TName;

package/sqlite-core/columns/common.d.cts

@@ -0,0 +1,35 @@
+import type { ColumnBuilderBase, ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnBuilderRuntimeConfig, ColumnDataType } from '../../column-builder.js';
+import { ColumnBuilder } from '../../column-builder.js';
+import { Column } from '../../column.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { UpdateDeleteAction } from '../foreign-keys.js';
+import type { SQLiteTable } from '../table.js';
+import { type Update } from '../../utils.js';
+export interface ReferenceConfig {
+    ref: () => SQLiteColumn;
+    actions: {
+        onUpdate?: UpdateDeleteAction;
+        onDelete?: UpdateDeleteAction;
+    };
+}
+export interface SQLiteColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> extends ColumnBuilderBase<T, TTypeConfig & {
+    dialect: 'sqlite';
+}> {
+}
+export declare abstract class SQLiteColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuilderExtraConfig = object> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & {
+    dialect: 'sqlite';
+}, TExtraConfig> implements SQLiteColumnBuilderBase<T, TTypeConfig> {
+    static readonly [entityKind]: string;
+    private foreignKeyConfigs;
+    references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;
+    unique(name?: string): this;
+}
+export declare abstract class SQLiteColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends Column<T, TRuntimeConfig, {
+    dialect: 'sqlite';
+}> {
+    readonly table: SQLiteTable;
+    static readonly [entityKind]: string;
+    constructor(table: SQLiteTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+export type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = SQLiteColumn<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;

package/sqlite-core/columns/common.d.mts

@@ -0,0 +1,35 @@
+import type { ColumnBuilderBase, ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnBuilderRuntimeConfig, ColumnDataType } from '../../column-builder.js';
+import { ColumnBuilder } from '../../column-builder.js';
+import { Column } from '../../column.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { UpdateDeleteAction } from '../foreign-keys.js';
+import type { SQLiteTable } from '../table.js';
+import { type Update } from '../../utils.js';
+export interface ReferenceConfig {
+    ref: () => SQLiteColumn;
+    actions: {
+        onUpdate?: UpdateDeleteAction;
+        onDelete?: UpdateDeleteAction;
+    };
+}
+export interface SQLiteColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> extends ColumnBuilderBase<T, TTypeConfig & {
+    dialect: 'sqlite';
+}> {
+}
+export declare abstract class SQLiteColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuilderExtraConfig = object> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & {
+    dialect: 'sqlite';
+}, TExtraConfig> implements SQLiteColumnBuilderBase<T, TTypeConfig> {
+    static readonly [entityKind]: string;
+    private foreignKeyConfigs;
+    references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;
+    unique(name?: string): this;
+}
+export declare abstract class SQLiteColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends Column<T, TRuntimeConfig, {
+    dialect: 'sqlite';
+}> {
+    readonly table: SQLiteTable;
+    static readonly [entityKind]: string;
+    constructor(table: SQLiteTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+export type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = SQLiteColumn<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;

package/sqlite-core/columns/common.d.ts

@@ -1,11 +1,11 @@
-import type { ColumnBaseConfig } from '../../column';
-import { Column } from '../../column';
-import type { ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnBuilderRuntimeConfig, ColumnDataType } from '../../column-builder';
-import { ColumnBuilder } from '../../column-builder';
-import { entityKind } from '../../entity';
-import type { UpdateDeleteAction } from '../foreign-keys';
-import type { SQLiteTable } from '../table';
-import { type Update } from '../../utils';
+import type { ColumnBuilderBase, ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnBuilderRuntimeConfig, ColumnDataType } from '../../column-builder.js';
+import { ColumnBuilder } from '../../column-builder.js';
+import { Column } from '../../column.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { UpdateDeleteAction } from '../foreign-keys.js';
+import type { SQLiteTable } from '../table.js';
+import { type Update } from '../../utils.js';
 export interface ReferenceConfig {
     ref: () => SQLiteColumn;
     actions: {
@@ -13,11 +13,13 @@ export interface ReferenceConfig {
         onDelete?: UpdateDeleteAction;
     };
 }
-export declare abstract class SQLiteColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string> & {
-    data: any;
-}, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuilderExtraConfig = object> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & {
+export interface SQLiteColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> extends ColumnBuilderBase<T, TTypeConfig & {
     dialect: 'sqlite';
-}, TExtraConfig> {
+}> {
+}
+export declare abstract class SQLiteColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuilderExtraConfig = object> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & {
+    dialect: 'sqlite';
+}, TExtraConfig> implements SQLiteColumnBuilderBase<T, TTypeConfig> {
     static readonly [entityKind]: string;
     private foreignKeyConfigs;
     references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;

package/sqlite-core/columns/custom.d.cts

@@ -0,0 +1,148 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SQL } from '../../sql/index.js';
+import type { AnySQLiteTable } from '../table.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
+export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
+    name: TName;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    data: T['data'];
+    driverParam: T['driverData'];
+    enumValues: undefined;
+} & (T['notNull'] extends true ? {
+    notNull: true;
+} : {}) & (T['default'] extends true ? {
+    hasDefault: true;
+} : {});
+export interface SQLiteCustomColumnInnerConfig {
+    customTypeValues: CustomTypeValues;
+}
+export declare class SQLiteCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'SQLiteCustomColumn'>> extends SQLiteColumnBuilder<T, {
+    fieldConfig: CustomTypeValues['config'];
+    customTypeParams: CustomTypeParams<any>;
+}, {
+    sqliteColumnBuilderBrand: 'SQLiteCustomColumnBuilderBrand';
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name'], fieldConfig: CustomTypeValues['config'], customTypeParams: CustomTypeParams<any>);
+}
+export declare class SQLiteCustomColumn<T extends ColumnBaseConfig<'custom', 'SQLiteCustomColumn'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    private sqlName;
+    private mapTo?;
+    private mapFrom?;
+    constructor(table: AnySQLiteTable<{
+        name: T['tableName'];
+    }>, config: SQLiteCustomColumnBuilder<T>['config']);
+    getSQLType(): string;
+    mapFromDriverValue(value: T['driverParam']): T['data'];
+    mapToDriverValue(value: T['data']): T['driverParam'];
+}
+export type CustomTypeValues = {
+    /**
+     * Required type for custom column, that will infer proper type model
+     *
+     * Examples:
+     *
+     * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+     *
+     * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+     */
+    data: unknown;
+    /**
+     * Type helper, that represents what type database driver is accepting for specific database data type
+     */
+    driverData?: unknown;
+    /**
+     * What config type should be used for {@link CustomTypeParams} `dataType` generation
+     */
+    config?: unknown;
+    /**
+     * Whether the config argument should be required or not
+     * @default false
+     */
+    configRequired?: boolean;
+    /**
+     * If your custom data type should be notNull by default you can use `notNull: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    notNull?: boolean;
+    /**
+     * If your custom data type has default you can use `default: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    default?: boolean;
+};
+export interface CustomTypeParams<T extends CustomTypeValues> {
+    /**
+     * Database data type string representation, that is used for migrations
+     * @example
+     * ```
+     * `jsonb`, `text`
+     * ```
+     *
+     * If database data type needs additional params you can use them from `config` param
+     * @example
+     * ```
+     * `varchar(256)`, `numeric(2,3)`
+     * ```
+     *
+     * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+     *
+     * @example
+     * Usage example
+     * ```
+     *   dataType() {
+     *     return 'boolean';
+     *   },
+     * ```
+     * Or
+     * ```
+     *   dataType(config) {
+     * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+     * 	 }
+     * ```
+     */
+    dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+    /**
+     * Optional mapping function, between user input and driver
+     * @example
+     * For example, when using jsonb we need to map JS/TS object to string before writing to database
+     * ```
+     * toDriver(value: TData): string {
+     * 	 return JSON.stringify(value);
+     * }
+     * ```
+     */
+    toDriver?: (value: T['data']) => T['driverData'] | SQL;
+    /**
+     * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+     * @example
+     * For example, when using timestamp we need to map string Date representation to JS Date
+     * ```
+     * fromDriver(value: string): Date {
+     * 	return new Date(value);
+     * },
+     * ```
+     */
+    fromDriver?: (value: T['driverData']) => T['data'];
+}
+/**
+ * Custom sqlite database data type generator
+ */
+export declare function customType<T extends CustomTypeValues = CustomTypeValues>(customTypeParams: CustomTypeParams<T>): Equal<T['configRequired'], true> extends true ? <TName extends string>(dbName: TName, fieldConfig: T['config']) => SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>> : <TName extends string>(dbName: TName, fieldConfig?: T['config']) => SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>>;

package/sqlite-core/columns/custom.d.mts

@@ -0,0 +1,148 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SQL } from '../../sql/index.js';
+import type { AnySQLiteTable } from '../table.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
+export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
+    name: TName;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    data: T['data'];
+    driverParam: T['driverData'];
+    enumValues: undefined;
+} & (T['notNull'] extends true ? {
+    notNull: true;
+} : {}) & (T['default'] extends true ? {
+    hasDefault: true;
+} : {});
+export interface SQLiteCustomColumnInnerConfig {
+    customTypeValues: CustomTypeValues;
+}
+export declare class SQLiteCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'SQLiteCustomColumn'>> extends SQLiteColumnBuilder<T, {
+    fieldConfig: CustomTypeValues['config'];
+    customTypeParams: CustomTypeParams<any>;
+}, {
+    sqliteColumnBuilderBrand: 'SQLiteCustomColumnBuilderBrand';
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name'], fieldConfig: CustomTypeValues['config'], customTypeParams: CustomTypeParams<any>);
+}
+export declare class SQLiteCustomColumn<T extends ColumnBaseConfig<'custom', 'SQLiteCustomColumn'>> extends SQLiteColumn<T> {
+    static readonly [entityKind]: string;
+    private sqlName;
+    private mapTo?;
+    private mapFrom?;
+    constructor(table: AnySQLiteTable<{
+        name: T['tableName'];
+    }>, config: SQLiteCustomColumnBuilder<T>['config']);
+    getSQLType(): string;
+    mapFromDriverValue(value: T['driverParam']): T['data'];
+    mapToDriverValue(value: T['data']): T['driverParam'];
+}
+export type CustomTypeValues = {
+    /**
+     * Required type for custom column, that will infer proper type model
+     *
+     * Examples:
+     *
+     * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+     *
+     * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+     */
+    data: unknown;
+    /**
+     * Type helper, that represents what type database driver is accepting for specific database data type
+     */
+    driverData?: unknown;
+    /**
+     * What config type should be used for {@link CustomTypeParams} `dataType` generation
+     */
+    config?: unknown;
+    /**
+     * Whether the config argument should be required or not
+     * @default false
+     */
+    configRequired?: boolean;
+    /**
+     * If your custom data type should be notNull by default you can use `notNull: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    notNull?: boolean;
+    /**
+     * If your custom data type has default you can use `default: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    default?: boolean;
+};
+export interface CustomTypeParams<T extends CustomTypeValues> {
+    /**
+     * Database data type string representation, that is used for migrations
+     * @example
+     * ```
+     * `jsonb`, `text`
+     * ```
+     *
+     * If database data type needs additional params you can use them from `config` param
+     * @example
+     * ```
+     * `varchar(256)`, `numeric(2,3)`
+     * ```
+     *
+     * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+     *
+     * @example
+     * Usage example
+     * ```
+     *   dataType() {
+     *     return 'boolean';
+     *   },
+     * ```
+     * Or
+     * ```
+     *   dataType(config) {
+     * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+     * 	 }
+     * ```
+     */
+    dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+    /**
+     * Optional mapping function, between user input and driver
+     * @example
+     * For example, when using jsonb we need to map JS/TS object to string before writing to database
+     * ```
+     * toDriver(value: TData): string {
+     * 	 return JSON.stringify(value);
+     * }
+     * ```
+     */
+    toDriver?: (value: T['data']) => T['driverData'] | SQL;
+    /**
+     * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+     * @example
+     * For example, when using timestamp we need to map string Date representation to JS Date
+     * ```
+     * fromDriver(value: string): Date {
+     * 	return new Date(value);
+     * },
+     * ```
+     */
+    fromDriver?: (value: T['driverData']) => T['data'];
+}
+/**
+ * Custom sqlite database data type generator
+ */
+export declare function customType<T extends CustomTypeValues = CustomTypeValues>(customTypeParams: CustomTypeParams<T>): Equal<T['configRequired'], true> extends true ? <TName extends string>(dbName: TName, fieldConfig: T['config']) => SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>> : <TName extends string>(dbName: TName, fieldConfig?: T['config']) => SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>>;

package/sqlite-core/columns/custom.d.ts

@@ -1,10 +1,10 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import type { SQL } from '../../sql';
-import type { AnySQLiteTable } from '../table';
-import { type Equal } from '../../utils';
-import { SQLiteColumn, SQLiteColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { SQL } from '../../sql/index.js';
+import type { AnySQLiteTable } from '../table.js';
+import { type Equal } from '../../utils.js';
+import { SQLiteColumn, SQLiteColumnBuilder } from './common.js';
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
     name: TName;
     dataType: 'custom';

package/sqlite-core/columns/index.d.cts

@@ -0,0 +1,7 @@
+export * from './blob.js';
+export * from './common.js';
+export * from './custom.js';
+export * from './integer.js';
+export * from './numeric.js';
+export * from './real.js';
+export * from './text.js';

package/sqlite-core/columns/index.d.mts

@@ -0,0 +1,7 @@
+export * from './blob.js';
+export * from './common.js';
+export * from './custom.js';
+export * from './integer.js';
+export * from './numeric.js';
+export * from './real.js';
+export * from './text.js';

package/sqlite-core/columns/index.d.ts

@@ -1,7 +1,7 @@
-export * from './blob';
-export * from './common';
-export * from './custom';
-export * from './integer';
-export * from './numeric';
-export * from './real';
-export * from './text';
+export * from './blob.js';
+export * from './common.js';
+export * from './custom.js';
+export * from './integer.js';
+export * from './numeric.js';
+export * from './real.js';
+export * from './text.js';