@type32/tauri-sqlite-orm 0.3.0 → 0.4.0

package/dist/relations-v2.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Relations v2 API - Drizzle-style defineRelations with from/to and many-without-one.
+ * Use defineRelations() for a single place to define all relations, or defineRelationsPart() to split into parts.
+ */
+import { AnySQLiteColumn, AnyTable } from './types';
+import { OneRelation, ManyRelation } from './orm';
+import type { Condition } from './operators';
+/** Options for one() relation - from/to replace fields/references */
+export interface OneRelationOptions {
+    from: AnySQLiteColumn | AnySQLiteColumn[];
+    to: AnySQLiteColumn | AnySQLiteColumn[];
+    optional?: boolean;
+    alias?: string;
+}
+/** Reference for through() - column with junction column for many-to-many */
+export interface ThroughRef {
+    column: AnySQLiteColumn;
+    junctionColumn: AnySQLiteColumn;
+    junctionTable: AnyTable;
+}
+/** Create a through reference for many-to-many: through(column, junctionColumn, junctionTable) */
+export declare function through(column: AnySQLiteColumn, junctionColumn: AnySQLiteColumn, junctionTable: AnyTable): ThroughRef;
+/** Options for many() relation - optional explicit from/to for many-without-one, or through() for many-to-many */
+export interface ManyRelationOptions {
+    from?: AnySQLiteColumn | AnySQLiteColumn[] | ThroughRef;
+    to?: AnySQLiteColumn | AnySQLiteColumn[] | ThroughRef;
+    optional?: boolean;
+    alias?: string;
+    /** Predefined filter: (alias) => Condition. Applied to the joined relation table. */
+    where?: (alias: string) => Condition;
+}
+/** Extract table keys from schema (values that extend AnyTable) */
+type ExtractTableKeys<T> = {
+    [K in keyof T]: T[K] extends AnyTable ? K : never;
+}[keyof T];
+type ExtractTables<T extends Record<string, unknown>> = Pick<T, Extract<ExtractTableKeys<T>, keyof T>> extends infer R ? R extends Record<string, AnyTable> ? R : Record<string, AnyTable> : Record<string, AnyTable>;
+/** Build the r object passed to defineRelations callback - all properties required to avoid TS2722 */
+export type BuildR<Tables extends Record<string, AnyTable>> = {
+    [K in keyof Tables]: Tables[K]['_']['columns'];
+} & {
+    one: {
+        [K in keyof Tables]: (opts: OneRelationOptions) => OneRelation<Tables[K]>;
+    };
+    many: {
+        [K in keyof Tables]: (opts?: ManyRelationOptions) => ManyRelation<Tables[K]>;
+    };
+};
+export type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: BuildR<Tables>) => {
+    [K in keyof Tables]?: Record<string, OneRelation | ManyRelation>;
+};
+/**
+ * Define all relations for your schema in one place (v2 API).
+ * Uses from/to instead of fields/references, and supports many-without-one.
+ *
+ * @example
+ * ```ts
+ * import * as schema from './schema'
+ * import { defineRelations } from '@type32/tauri-sqlite-orm'
+ *
+ * export const relations = defineRelations(schema, (r) => ({
+ *   users: {
+ *     posts: r.many.posts({ from: r.users.id, to: r.posts.userId }),
+ *   },
+ *   posts: {
+ *     user: r.one.users({ from: r.posts.userId, to: r.users.id }),
+ *     postTags: r.many.postTags({ from: r.posts.id, to: r.postTags.postId }),
+ *   },
+ * }))
+ * ```
+ */
+export declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<ExtractTables<TSchema>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+/**
+ * Define a part of relations - merge multiple parts when passing to TauriORM.
+ * Useful for splitting large schema definitions.
+ */
+export declare function defineRelationsPart<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<Record<string, AnyTable>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+export {};

package/dist/relations-v2.js

@@ -0,0 +1,157 @@
+/**
+ * Relations v2 API - Drizzle-style defineRelations with from/to and many-without-one.
+ * Use defineRelations() for a single place to define all relations, or defineRelationsPart() to split into parts.
+ */
+import { OneRelation, ManyRelation } from './orm';
+/** Extract tables from a schema object (filters to Table instances with _ and relations) */
+function extractTables(schema) {
+    const tables = {};
+    for (const [key, value] of Object.entries(schema)) {
+        const v = value;
+        if (v && typeof v === 'object' && v._?.name && v._?.columns && typeof v.relations === 'object') {
+            tables[key] = v;
+        }
+    }
+    return tables;
+}
+/** Create a through reference for many-to-many: through(column, junctionColumn, junctionTable) */
+export function through(column, junctionColumn, junctionTable) {
+    return { column, junctionColumn, junctionTable };
+}
+/** Normalize column(s) to array */
+function toArray(col) {
+    return Array.isArray(col) ? col : [col];
+}
+/** Check if value is ThroughRef */
+function isThroughRef(v) {
+    return v && typeof v === 'object' && 'column' in v && 'junctionColumn' in v && 'junctionTable' in v;
+}
+/** Build table column references for use in from/to - r.users.id etc. */
+function buildTableRef(table) {
+    return { ...table._.columns };
+}
+function buildR(tables) {
+    const tableRefs = {};
+    const oneFns = {};
+    const manyFns = {};
+    for (const [tableKey, table] of Object.entries(tables)) {
+        tableRefs[tableKey] = buildTableRef(table);
+        const foreignTable = table;
+        oneFns[tableKey] = (opts) => {
+            return new OneRelation(foreignTable, {
+                fields: toArray(opts.from),
+                references: toArray(opts.to),
+                optional: opts.optional,
+                alias: opts.alias,
+            });
+        };
+        manyFns[tableKey] = (opts) => {
+            if (!opts?.from || !opts?.to)
+                return new ManyRelation(foreignTable);
+            if (isThroughRef(opts.from) && isThroughRef(opts.to)) {
+                return new ManyRelation(foreignTable, {
+                    through: {
+                        junctionTable: opts.from.junctionTable,
+                        fromRef: { column: opts.from.column, junctionColumn: opts.from.junctionColumn },
+                        toRef: { column: opts.to.column, junctionColumn: opts.to.junctionColumn },
+                    },
+                    optional: opts.optional,
+                    alias: opts.alias,
+                    where: opts.where,
+                });
+            }
+            return new ManyRelation(foreignTable, {
+                from: toArray(opts.from),
+                to: toArray(opts.to),
+                optional: opts.optional,
+                alias: opts.alias,
+                where: opts.where,
+            });
+        };
+    }
+    return {
+        ...tableRefs,
+        one: oneFns,
+        many: manyFns,
+    };
+}
+/** Apply relations from defineRelations result to tables */
+function applyRelationsToTables(tables, relationsResult) {
+    for (const [tableKey, rels] of Object.entries(relationsResult)) {
+        const table = tables[tableKey];
+        if (!table)
+            continue;
+        for (const [relName, relation] of Object.entries(rels)) {
+            if (relation instanceof OneRelation) {
+                table.relations[relName] = {
+                    type: 'one',
+                    foreignTable: relation.foreignTable,
+                    fields: relation.config?.fields,
+                    references: relation.config?.references,
+                    optional: relation.config?.optional,
+                    alias: relation.config?.alias,
+                };
+            }
+            else if (relation instanceof ManyRelation) {
+                const config = relation.config;
+                if (config?.through) {
+                    table.relations[relName] = {
+                        type: 'many',
+                        foreignTable: relation.foreignTable,
+                        junctionTable: config.through.junctionTable,
+                        fromJunction: config.through.fromRef,
+                        toJunction: config.through.toRef,
+                        optional: config.optional,
+                        alias: config.alias,
+                        where: config.where,
+                    };
+                }
+                else {
+                    table.relations[relName] = {
+                        type: 'many',
+                        foreignTable: relation.foreignTable,
+                        fields: config ? config.to : undefined,
+                        references: config ? config.from : undefined,
+                        optional: config?.optional,
+                        alias: config?.alias,
+                        where: config?.where,
+                    };
+                }
+            }
+        }
+    }
+}
+/**
+ * Define all relations for your schema in one place (v2 API).
+ * Uses from/to instead of fields/references, and supports many-without-one.
+ *
+ * @example
+ * ```ts
+ * import * as schema from './schema'
+ * import { defineRelations } from '@type32/tauri-sqlite-orm'
+ *
+ * export const relations = defineRelations(schema, (r) => ({
+ *   users: {
+ *     posts: r.many.posts({ from: r.users.id, to: r.posts.userId }),
+ *   },
+ *   posts: {
+ *     user: r.one.users({ from: r.posts.userId, to: r.users.id }),
+ *     postTags: r.many.postTags({ from: r.posts.id, to: r.postTags.postId }),
+ *   },
+ * }))
+ * ```
+ */
+export function defineRelations(schema, callback) {
+    const tables = extractTables(schema);
+    const r = buildR(tables);
+    const result = callback(r);
+    applyRelationsToTables(tables, result);
+    return result;
+}
+/**
+ * Define a part of relations - merge multiple parts when passing to TauriORM.
+ * Useful for splitting large schema definitions.
+ */
+export function defineRelationsPart(schema, callback) {
+    return defineRelations(schema, callback);
+}

package/dist/serialization.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Serialization and Deserialization utilities for SQLite type conversion
+ */
+import { AnySQLiteColumn } from './types';
+/**
+ * Serialize JavaScript value to SQLite-compatible format
+ * Used for INSERT and UPDATE operations
+ */
+export declare function serializeValue(value: any, column: AnySQLiteColumn): any;
+/**
+ * Deserialize SQLite value to proper TypeScript type
+ * Used for SELECT operations
+ */
+export declare function deserializeValue(value: any, column: AnySQLiteColumn): any;

package/dist/serialization.js

@@ -0,0 +1,135 @@
+/**
+ * Serialization and Deserialization utilities for SQLite type conversion
+ */
+/**
+ * Serialize JavaScript value to SQLite-compatible format
+ * Used for INSERT and UPDATE operations
+ */
+export function serializeValue(value, column) {
+    // Handle null/undefined
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const { dataType, mode } = column._;
+    // TEXT type
+    if (dataType === 'TEXT') {
+        if (mode === 'json') {
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        }
+        return String(value);
+    }
+    // INTEGER type
+    if (dataType === 'INTEGER') {
+        if (mode === 'timestamp' || mode === 'timestamp_ms') {
+            // Convert Date to timestamp
+            if (value instanceof Date) {
+                return mode === 'timestamp_ms' ? value.getTime() : Math.floor(value.getTime() / 1000);
+            }
+            // If already a number, pass through
+            return typeof value === 'number' ? value : parseInt(String(value), 10);
+        }
+        if (mode === 'boolean') {
+            // Convert boolean to 0/1
+            return value ? 1 : 0;
+        }
+        // Regular integer
+        return typeof value === 'number' ? Math.floor(value) : parseInt(String(value), 10);
+    }
+    // REAL type
+    if (dataType === 'REAL') {
+        return typeof value === 'number' ? value : parseFloat(String(value));
+    }
+    // BOOLEAN type
+    if (dataType === 'BOOLEAN') {
+        return value ? 1 : 0;
+    }
+    // BLOB type
+    if (dataType === 'BLOB') {
+        if (mode === 'json') {
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        }
+        if (mode === 'bigint') {
+            return String(value); // SQLite stores bigint as string
+        }
+        return value;
+    }
+    // NUMERIC type
+    if (dataType === 'NUMERIC') {
+        if (mode === 'bigint') {
+            return String(value); // SQLite stores bigint as string
+        }
+        return typeof value === 'number' ? value : parseFloat(String(value));
+    }
+    return value;
+}
+/**
+ * Deserialize SQLite value to proper TypeScript type
+ * Used for SELECT operations
+ */
+export function deserializeValue(value, column) {
+    // Handle null/undefined
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const { dataType, mode } = column._;
+    // TEXT type
+    if (dataType === 'TEXT') {
+        if (mode === 'json') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value; // Already string
+    }
+    // INTEGER type
+    if (dataType === 'INTEGER') {
+        if (mode === 'timestamp' || mode === 'timestamp_ms') {
+            // SQLite stores timestamps as numbers, convert to Date
+            const num = typeof value === 'string' ? parseInt(value, 10) : value;
+            if (isNaN(num))
+                return null;
+            return mode === 'timestamp_ms' ? new Date(num) : new Date(num * 1000);
+        }
+        if (mode === 'boolean') {
+            // SQLite stores booleans as 0/1
+            return value === 1 || value === '1' || value === true;
+        }
+        // Regular integer
+        return typeof value === 'string' ? parseInt(value, 10) : value;
+    }
+    // REAL type
+    if (dataType === 'REAL') {
+        return typeof value === 'string' ? parseFloat(value) : value;
+    }
+    // BOOLEAN type
+    if (dataType === 'BOOLEAN') {
+        return value === 1 || value === '1' || value === true;
+    }
+    // BLOB type
+    if (dataType === 'BLOB') {
+        if (mode === 'json') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        if (mode === 'bigint') {
+            return typeof value === 'string' ? BigInt(value) : BigInt(value);
+        }
+        // Assume Uint8Array or similar
+        return value;
+    }
+    // NUMERIC type
+    if (dataType === 'NUMERIC') {
+        if (mode === 'bigint') {
+            return typeof value === 'string' ? BigInt(value) : BigInt(value);
+        }
+        return typeof value === 'string' ? parseFloat(value) : value;
+    }
+    return value;
+}

package/dist/subquery.d.ts

@@ -0,0 +1,5 @@
+import { Expression } from 'kysely';
+import { SelectQueryBuilder } from './builders/select';
+import { AnyTable } from './types';
+export declare const subquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => Expression<any>;
+export declare const scalarSubquery: <T extends AnyTable>(query: SelectQueryBuilder<T, any>) => Expression<any>;

package/dist/subquery.js

@@ -0,0 +1,6 @@
+export const subquery = (query) => {
+    return query.toKyselyExpression();
+};
+export const scalarSubquery = (query) => {
+    return query.toKyselyExpression();
+};

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+import { SQLiteColumn, Table } from './orm';
+export type ColumnDataType = 'TEXT' | 'INTEGER' | 'REAL' | 'BLOB' | 'BOOLEAN' | 'NUMERIC';
+export type Mode = 'default' | 'timestamp' | 'timestamp_ms' | 'json' | 'boolean' | 'bigint';
+export type ColumnValueTypes<TType extends ColumnDataType, TMode extends Mode> = TType extends 'TEXT' ? TMode extends 'json' ? unknown : string : TType extends 'INTEGER' ? TMode extends 'timestamp' | 'timestamp_ms' ? Date : TMode extends 'boolean' ? boolean : number : TType extends 'REAL' ? number : TType extends 'BOOLEAN' ? boolean : TType extends 'BLOB' ? TMode extends 'json' ? unknown : TMode extends 'bigint' ? bigint : Uint8Array : TType extends 'NUMERIC' ? TMode extends 'bigint' ? bigint : number : never;
+export interface ColumnOptions<TData, TEnum extends readonly string[] = readonly string[]> {
+    notNull?: boolean;
+    default?: TData;
+    $defaultFn?: () => TData;
+    primaryKey?: boolean;
+    autoincrement?: boolean;
+    unique?: boolean;
+    references?: {
+        table: AnyTable;
+        column: AnySQLiteColumn;
+        onDelete?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+        onUpdate?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+    };
+    mode?: Mode;
+    $onUpdateFn?: () => TData;
+    enum?: TEnum;
+}
+export type ExtractColumnType<T extends AnySQLiteColumn> = T extends SQLiteColumn<infer _, infer TType, infer TMode, infer TNotNull, infer THasDefault, infer TAutoincrement, infer TEnum, infer TCustomType> ? [
+    TCustomType
+] extends [never] ? [
+    TEnum
+] extends [never] ? TNotNull extends true ? ColumnValueTypes<TType, TMode> : ColumnValueTypes<TType, TMode> | null : TNotNull extends true ? TEnum[number] : TEnum[number] | null : TNotNull extends true ? TCustomType : TCustomType | null : never;
+export type AnySQLiteColumn = SQLiteColumn<any, any, any, any, any, any, any, any>;
+export type AnyTable = Table<Record<string, AnySQLiteColumn>, string>;
+export type InferSelectModel<T extends AnyTable> = {
+    [K in keyof T['_']['columns']]: ExtractColumnType<T['_']['columns'][K]>;
+};
+export type RelationType = 'one' | 'many';
+export interface RelationConfig {
+    type: RelationType;
+    foreignTable: AnyTable;
+    /** For one: local FK columns. For many (v2): foreign table's FK columns. */
+    fields?: AnySQLiteColumn[];
+    /** For one: foreign PK columns. For many (v2): parent table's PK columns. */
+    references?: AnySQLiteColumn[];
+    /** For many-to-many via through(): junction table between parent and foreign */
+    junctionTable?: AnyTable;
+    /** Parent column -> junction column (parent PK = junction FK to parent) */
+    fromJunction?: {
+        column: AnySQLiteColumn;
+        junctionColumn: AnySQLiteColumn;
+    };
+    /** Junction column -> foreign column (junction FK to foreign = foreign PK) */
+    toJunction?: {
+        junctionColumn: AnySQLiteColumn;
+        column: AnySQLiteColumn;
+    };
+    /** When false, one relation is required (type-level: T not T | null) */
+    optional?: boolean;
+    /** Alias for the relation (e.g. for self-referential disambiguation) */
+    alias?: string;
+    /** Predefined filter for many relations: (alias) => Condition. Receives the joined table alias. */
+    where?: (alias: string) => unknown;
+}

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@type32/tauri-sqlite-orm",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "A Drizzle-like ORM for Tauri v2's SQL JS API plugin.",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",
@@ -19,6 +19,7 @@
         "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
         "test": "bun test",
         "release:minor": "bun run build && bun pm version minor && bun publish",
+        "release:prerelease": "bun run build && bun pm version minor && bun publish",
         "release:patch": "bun run build && bun pm version patch && bun publish"
     },
     "keywords": [