@type32/tauri-sqlite-orm 0.3.0 → 0.4.0

package/dist/orm.js

@@ -0,0 +1,556 @@
+import { Kysely, sql as kyselySql } from 'kysely';
+import { TauriDialect } from './dialect';
+import { SelectQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder, WithQueryBuilder, } from './builders';
+// Column class
+export class SQLiteColumn {
+    type;
+    options;
+    _;
+    constructor(name, type, options = {}) {
+        this.type = type;
+        this.options = options;
+        this._ = {
+            name,
+            dataType: type,
+            mode: (options.mode || 'default'),
+            notNull: (options.notNull ?? false),
+            hasDefault: (options.default !== undefined || options.$defaultFn !== undefined),
+            autoincrement: (options.autoincrement ?? false),
+            enum: options.enum,
+            customType: undefined,
+        };
+    }
+    notNull() {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, notNull: true, mode: this._.mode });
+    }
+    default(value) {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, default: value, mode: this._.mode });
+    }
+    $defaultFn(fn) {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, $defaultFn: fn, mode: this._.mode });
+    }
+    primaryKey() {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, primaryKey: true, notNull: true, mode: this._.mode });
+    }
+    autoincrement() {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, autoincrement: true, mode: this._.mode });
+    }
+    unique() {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, unique: true, mode: this._.mode });
+    }
+    references(ref, column, options) {
+        const columnKey = typeof column === 'string' ? column : column._.name;
+        const columnObj = typeof column === 'string' ? ref._.columns[column] : column;
+        return new SQLiteColumn(this._.name, this.type, {
+            ...this.options,
+            references: {
+                table: ref,
+                column: columnObj,
+                onDelete: options?.onDelete,
+                onUpdate: options?.onUpdate,
+            },
+            mode: this._.mode
+        });
+    }
+    $onUpdateFn(fn) {
+        return new SQLiteColumn(this._.name, this.type, { ...this.options, $onUpdateFn: fn, mode: this._.mode });
+    }
+    $type() {
+        return this;
+    }
+    as(alias) {
+        // This is a placeholder for alias functionality
+        return this;
+    }
+}
+export class Table {
+    _;
+    relations = {};
+    constructor(name, columns) {
+        this._ = {
+            name,
+            columns,
+        };
+    }
+}
+export const sqliteTable = (tableName, columns) => {
+    return new Table(tableName, columns);
+};
+export const asc = (column) => kyselySql `${kyselySql.ref(column._.name)} ASC`;
+export const desc = (column) => kyselySql `${kyselySql.ref(column._.name)} DESC`;
+// Main ORM Class
+export class TauriORM {
+    db;
+    tables = new Map();
+    kysely;
+    constructor(db, schema = undefined) {
+        this.db = db;
+        this.kysely = new Kysely({ dialect: new TauriDialect(db) });
+        if (schema) {
+            for (const [, value] of Object.entries(schema)) {
+                if (value instanceof Table) {
+                    this.tables.set(value._.name, value);
+                }
+            }
+        }
+    }
+    buildColumnDefinition(col, forAlterTable = false) {
+        let sql = `${col._.name} ${col.type}`;
+        if (col.options.primaryKey && !forAlterTable) {
+            sql += ' PRIMARY KEY';
+            if (col._.autoincrement) {
+                sql += ' AUTOINCREMENT';
+            }
+        }
+        if (col._.notNull)
+            sql += ' NOT NULL';
+        if (col.options.unique)
+            sql += ' UNIQUE';
+        if (col.options.default !== undefined) {
+            const value = col.options.default;
+            sql += ` DEFAULT ${typeof value === 'string' ? `'${value.replace(/'/g, "''")}'` : value}`;
+        }
+        if (col.options.references) {
+            sql += ` REFERENCES ${col.options.references.table._.name}(${col.options.references.column._.name})`;
+            if (col.options.references.onDelete) {
+                sql += ` ON DELETE ${col.options.references.onDelete.toUpperCase()}`;
+            }
+            if (col.options.references.onUpdate) {
+                sql += ` ON UPDATE ${col.options.references.onUpdate.toUpperCase()}`;
+            }
+        }
+        return sql;
+    }
+    async checkMigration() {
+        const dbTables = await this.db.select(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+        const dbTableNames = new Set(dbTables.map((t) => t.name));
+        const schemaTableNames = new Set(Array.from(this.tables.keys()));
+        const changes = {
+            tablesToCreate: [],
+            tablesToRecreate: [],
+            tablesToDrop: [],
+            columnsToAdd: [],
+        };
+        // Check tables to create
+        for (const tableName of schemaTableNames) {
+            if (!dbTableNames.has(tableName)) {
+                changes.tablesToCreate.push(tableName);
+            }
+        }
+        // Check tables to drop
+        for (const tableName of dbTableNames) {
+            if (!schemaTableNames.has(tableName)) {
+                changes.tablesToDrop.push(tableName);
+            }
+        }
+        // Check for table recreation and column additions
+        for (const table of this.tables.values()) {
+            const tableName = table._.name;
+            if (!dbTableNames.has(tableName))
+                continue;
+            const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
+            const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+            const uniqueColumns = new Set();
+            for (const index of existingIndexes) {
+                if (index.unique === 1 && index.origin === 'u') {
+                    const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+                    if (indexInfo.length === 1) {
+                        uniqueColumns.add(indexInfo[0].name);
+                    }
+                }
+            }
+            const existingColumns = new Map(existingTableInfo.map(c => [c.name, c]));
+            const schemaColumns = table._.columns;
+            let needsRecreate = false;
+            for (const [colName, column] of Object.entries(schemaColumns)) {
+                const dbColName = column._.name;
+                const existing = existingColumns.get(dbColName);
+                if (!existing) {
+                    if (!this.canAddColumnWithAlter(column)) {
+                        needsRecreate = true;
+                        break;
+                    }
+                    changes.columnsToAdd.push({ table: tableName, column: dbColName });
+                }
+                else {
+                    const hasUniqueInDB = uniqueColumns.has(dbColName);
+                    const wantsUnique = !!column.options.unique;
+                    if (hasUniqueInDB !== wantsUnique || this.hasColumnDefinitionChanged(column, existing)) {
+                        needsRecreate = true;
+                        break;
+                    }
+                }
+            }
+            // Check for removed columns (existingCol is DB name)
+            for (const existingCol of existingColumns.keys()) {
+                const schemaHasCol = Object.values(schemaColumns).some((c) => c._.name === existingCol);
+                if (!schemaHasCol) {
+                    needsRecreate = true;
+                    break;
+                }
+            }
+            if (needsRecreate) {
+                changes.tablesToRecreate.push(tableName);
+            }
+        }
+        const safe = changes.tablesToRecreate.length === 0 && changes.tablesToDrop.length === 0;
+        return { safe, changes };
+    }
+    async migrate(options) {
+        if (options?.dryRun) {
+            const check = await this.checkMigration();
+            console.log('[Tauri-ORM] Migration Preview (Dry Run):');
+            console.log('  Tables to create:', check.changes.tablesToCreate);
+            console.log('  Tables to recreate (DESTRUCTIVE):', check.changes.tablesToRecreate);
+            console.log('  Tables to drop:', check.changes.tablesToDrop);
+            console.log('  Columns to add:', check.changes.columnsToAdd);
+            console.log('  Safe migration:', check.safe);
+            return;
+        }
+        const dbTables = await this.db.select(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+        const dbTableNames = new Set(dbTables.map((t) => t.name));
+        const schemaTableNames = new Set(Array.from(this.tables.keys()));
+        // Create/update tables
+        for (const table of this.tables.values()) {
+            const tableName = table._.name;
+            const tableExists = dbTableNames.has(tableName);
+            if (!tableExists) {
+                // Table does not exist, create it
+                const columnsSql = Object.values(table._.columns)
+                    .map((col) => this.buildColumnDefinition(col))
+                    .join(', ');
+                const createSql = `CREATE TABLE ${tableName} (${columnsSql})`;
+                await this.db.execute(createSql);
+            }
+            else {
+                // Table exists, check for schema changes
+                const existingTableInfo = await this.db.select(`PRAGMA table_info('${tableName}')`);
+                // Get existing UNIQUE constraints from indexes
+                const existingIndexes = await this.db.select(`PRAGMA index_list('${tableName}')`);
+                const uniqueColumns = new Set();
+                for (const index of existingIndexes) {
+                    if (index.unique === 1 && index.origin === 'u') {
+                        const indexInfo = await this.db.select(`PRAGMA index_info('${index.name}')`);
+                        if (indexInfo.length === 1) {
+                            uniqueColumns.add(indexInfo[0].name);
+                        }
+                    }
+                }
+                const existingColumns = new Map(existingTableInfo.map(c => [c.name, c]));
+                const schemaColumns = table._.columns;
+                // Check if we need to recreate the table (column definition changes)
+                let needsRecreate = false;
+                const columnsToAdd = [];
+                for (const [colName, column] of Object.entries(schemaColumns)) {
+                    const dbColName = column._.name;
+                    const existing = existingColumns.get(dbColName);
+                    if (!existing) {
+                        // New column - check if it can be added with ALTER TABLE
+                        if (this.canAddColumnWithAlter(column)) {
+                            columnsToAdd.push(column);
+                        }
+                        else {
+                            needsRecreate = true;
+                            break;
+                        }
+                    }
+                    else {
+                        // Existing column - check if definition changed
+                        const hasUniqueInDB = uniqueColumns.has(dbColName);
+                        const wantsUnique = !!column.options.unique;
+                        if (hasUniqueInDB !== wantsUnique) {
+                            needsRecreate = true;
+                            break;
+                        }
+                        if (this.hasColumnDefinitionChanged(column, existing)) {
+                            needsRecreate = true;
+                            break;
+                        }
+                    }
+                }
+                // Check for removed columns (existingCol is DB name)
+                if (options?.performDestructiveActions) {
+                    for (const existingCol of existingColumns.keys()) {
+                        const schemaHasCol = Object.values(schemaColumns).some((c) => c._.name === existingCol);
+                        if (!schemaHasCol) {
+                            needsRecreate = true;
+                            break;
+                        }
+                    }
+                }
+                if (needsRecreate) {
+                    // Recreate table with new schema
+                    await this.recreateTable(tableName, table);
+                }
+                else if (columnsToAdd.length > 0) {
+                    // Just add new columns with ALTER TABLE
+                    for (const column of columnsToAdd) {
+                        const columnSql = this.buildColumnDefinition(column, true);
+                        await this.db.execute(`ALTER TABLE ${tableName} ADD COLUMN ${columnSql}`);
+                    }
+                }
+            }
+        }
+        // Drop extra tables if destructive actions are enabled
+        if (options?.performDestructiveActions) {
+            for (const tableName of dbTableNames) {
+                if (!schemaTableNames.has(tableName)) {
+                    await this.dropTable(tableName);
+                }
+            }
+        }
+    }
+    canAddColumnWithAlter(column) {
+        // SQLite ALTER TABLE ADD COLUMN has limitations:
+        // - Cannot add PRIMARY KEY
+        // - Cannot add UNIQUE (without using a workaround)
+        // - Can add NOT NULL only if column has a DEFAULT value
+        if (column.options.primaryKey)
+            return false;
+        if (column.options.unique)
+            return false;
+        if (column._.notNull && column.options.default === undefined && !column.options.$defaultFn)
+            return false;
+        return true;
+    }
+    hasColumnDefinitionChanged(column, existing) {
+        // Check if column type changed (normalize to uppercase)
+        if (column.type.toUpperCase() !== existing.type.toUpperCase())
+            return true;
+        // Check if NOT NULL changed
+        if (column._.notNull !== (existing.notnull === 1))
+            return true;
+        // Check if PRIMARY KEY changed
+        if (!!column.options.primaryKey !== (existing.pk === 1))
+            return true;
+        // Check if default value changed
+        const hasDefault = column.options.default !== undefined;
+        const existingHasDefault = existing.dflt_value !== null;
+        if (hasDefault !== existingHasDefault)
+            return true;
+        // Check UNIQUE constraint (requires checking indexes)
+        // For now, we'll check UNIQUE separately if needed
+        return false;
+    }
+    async recreateTable(tableName, table) {
+        const tempTableName = `${tableName}_new_${Date.now()}`;
+        // Create new table with updated schema
+        const columnsSql = Object.values(table._.columns)
+            .map((col) => this.buildColumnDefinition(col))
+            .join(', ');
+        await this.db.execute(`CREATE TABLE ${tempTableName} (${columnsSql})`);
+        // Copy data from old table (only columns that exist in both)
+        const oldColumns = await this.db.select(`PRAGMA table_info('${tableName}')`);
+        const oldColumnNames = oldColumns.map(c => c.name);
+        const newColumnNames = Object.values(table._.columns).map(c => c._.name);
+        const commonColumns = oldColumnNames.filter(name => newColumnNames.includes(name));
+        if (commonColumns.length > 0) {
+            const columnsList = commonColumns.join(', ');
+            await this.db.execute(`INSERT INTO ${tempTableName} (${columnsList}) SELECT ${columnsList} FROM ${tableName}`);
+        }
+        // Drop old table and rename new table
+        await this.db.execute(`DROP TABLE ${tableName}`);
+        await this.db.execute(`ALTER TABLE ${tempTableName} RENAME TO ${tableName}`);
+    }
+    select(table, columns) {
+        const internalTable = this.tables.get(table._.name);
+        if (!internalTable) {
+            console.warn(`[Tauri-ORM] Table "${table._.name}" was not passed in the schema to the ORM constructor. Relations will not be available.`);
+            return new SelectQueryBuilder(this.kysely, table, columns);
+        }
+        return new SelectQueryBuilder(this.kysely, internalTable, columns);
+    }
+    insert(table) {
+        return new InsertQueryBuilder(this.kysely, table);
+    }
+    update(table) {
+        return new UpdateQueryBuilder(this.kysely, table);
+    }
+    delete(table) {
+        return new DeleteQueryBuilder(this.kysely, table);
+    }
+    async upsert(table, data, conflictTarget) {
+        const columns = conflictTarget.map(col => table._.columns[col]);
+        return this.insert(table)
+            .values(data)
+            .onConflictDoUpdate({
+            target: columns.length === 1 ? columns[0] : columns,
+            set: data
+        })
+            .execute();
+    }
+    $with(alias) {
+        const withBuilder = new WithQueryBuilder(this.kysely);
+        return {
+            as: (query) => {
+                withBuilder.with(alias, query);
+                return withBuilder;
+            },
+        };
+    }
+    async transaction(callback) {
+        await this.db.execute('BEGIN');
+        try {
+            const result = await callback(this);
+            await this.db.execute('COMMIT');
+            return result;
+        }
+        catch (e) {
+            await this.db.execute('ROLLBACK');
+            throw e;
+        }
+    }
+    rollback() {
+        throw new Error('Transaction rolled back');
+    }
+    // --- Schema detection / signature ---
+    async ensureSchemaMeta() {
+        await this.db.execute(`CREATE TABLE IF NOT EXISTS _schema_meta
+             (
+                 key
+                 TEXT
+                 PRIMARY
+                 KEY,
+                 value
+                 TEXT
+                 NOT
+                 NULL
+             )`);
+    }
+    async getSchemaMeta(key) {
+        await this.ensureSchemaMeta();
+        const rows = await this.db.select(`SELECT value
+             FROM _schema_meta
+             WHERE key = ?`, [key]);
+        return rows?.[0]?.value ?? null;
+    }
+    async setSchemaMeta(key, value) {
+        await this.ensureSchemaMeta();
+        await this.db.execute(`INSERT INTO _schema_meta(key, value)
+             VALUES (?, ?) ON CONFLICT(key) DO
+             UPDATE
+             SET value = excluded.value`, [key, value]);
+    }
+    normalizeColumn(col) {
+        return {
+            name: col._.name,
+            type: col.type,
+            pk: !!col.options.primaryKey,
+            ai: !!col._.autoincrement,
+            nn: !!col._.notNull,
+            unique: !!col.options.unique,
+            dv: col.options.default && typeof col.options.default === 'object' && col.options.default.raw
+                ? { raw: col.options.default.raw }
+                : col.options.default ?? null,
+            hasDefaultFn: col.options.$defaultFn !== undefined,
+            hasOnUpdateFn: col.options.$onUpdateFn !== undefined,
+            onDelete: col.options.references?.onDelete ?? null,
+            onUpdate: col.options.references?.onUpdate ?? null,
+        };
+    }
+    computeModelSignature() {
+        const entries = Array.from(this.tables.values()).map((tbl) => {
+            const cols = Object.values(tbl._.columns)
+                .map((c) => this.normalizeColumn(c))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            return { table: tbl._.name, columns: cols };
+        });
+        entries.sort((a, b) => a.table.localeCompare(b.table));
+        return JSON.stringify(entries);
+    }
+    getSchemaSignature() {
+        return this.computeModelSignature();
+    }
+    async isSchemaDirty() {
+        const sig = this.computeModelSignature();
+        const stored = await this.getSchemaMeta('schema_signature');
+        return { dirty: sig !== stored, current: sig, stored };
+    }
+    async migrateIfDirty() {
+        const status = await this.isSchemaDirty();
+        if (status.dirty) {
+            await this.migrate();
+            await this.setSchemaMeta('schema_signature', this.computeModelSignature());
+            return true;
+        }
+        return false;
+    }
+    async doesTableExist(tableName) {
+        const result = await this.db.select(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [tableName]);
+        return result.length > 0;
+    }
+    async dropTable(tableName) {
+        await this.db.execute(`DROP TABLE IF EXISTS ${tableName}`);
+    }
+    async doesColumnExist(tableName, columnName) {
+        const result = await this.db.select(`PRAGMA table_info('${tableName}')`);
+        return result.some((col) => col.name === columnName);
+    }
+    async renameTable(from, to) {
+        await this.db.execute(`ALTER TABLE ${from} RENAME TO ${to}`);
+    }
+    async dropColumn(tableName, columnName) {
+        await this.db.execute(`ALTER TABLE ${tableName} DROP COLUMN ${columnName}`);
+    }
+    async renameColumn(tableName, from, to) {
+        await this.db.execute(`ALTER TABLE ${tableName} RENAME COLUMN ${from} TO ${to}`);
+    }
+}
+// Relations
+export class Relation {
+    foreignTable;
+    constructor(foreignTable) {
+        this.foreignTable = foreignTable;
+    }
+}
+export class OneRelation extends Relation {
+    config;
+    constructor(foreignTable, config) {
+        super(foreignTable);
+        this.config = config;
+    }
+}
+export class ManyRelation extends Relation {
+    config;
+    constructor(foreignTable, config) {
+        super(foreignTable);
+        this.config = config;
+    }
+}
+export const relations = (table, relationsCallback) => {
+    const builtRelations = relationsCallback({
+        one: (foreignTable, config) => {
+            return new OneRelation(foreignTable, config);
+        },
+        many: (foreignTable) => {
+            return new ManyRelation(foreignTable);
+        },
+    });
+    for (const [name, relation] of Object.entries(builtRelations)) {
+        if (relation instanceof OneRelation) {
+            table.relations[name] = {
+                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) {
+            table.relations[name] = {
+                type: 'many',
+                foreignTable: relation.foreignTable,
+            };
+        }
+    }
+    return builtRelations;
+};
+// Helper functions
+export const getTableColumns = (table) => {
+    return table._.columns;
+};
+export const alias = (table, alias) => {
+    // This is a placeholder for alias functionality
+    return table;
+};

package/dist/relational-types.d.ts

@@ -0,0 +1,87 @@
+import type { AnyTable, InferSelectModel } from './types';
+import type { OneRelation, ManyRelation } from './orm';
+/** Maps relations() return type to typed relation configs with foreign table preserved */
+export type InferRelationsMap<R extends Record<string, OneRelation | ManyRelation>> = {
+    [K in keyof R]: R[K] extends OneRelation<infer T> ? R[K] extends {
+        config?: {
+            optional?: infer O;
+        };
+    } ? {
+        type: 'one';
+        foreignTable: T;
+        optional: O;
+    } : {
+        type: 'one';
+        foreignTable: T;
+        optional?: true;
+    } : R[K] extends ManyRelation<infer T> ? {
+        type: 'many';
+        foreignTable: T;
+    } : never;
+};
+/** With/include object shape - matches NestedInclude from select builder */
+type WithShape = boolean | {
+    columns?: string[] | Record<string, boolean>;
+    with?: Record<string, WithShape>;
+};
+/** Map of table name -> relations() return type, for nested with support */
+type RelationsByTable = Record<string, Record<string, OneRelation | ManyRelation>>;
+/** Get relations for a table from the all-relations map */
+type GetRelationsForTable<TTable extends AnyTable, TAllRelations extends RelationsByTable> = TAllRelations[TTable['_']['name']] extends Record<string, OneRelation | ManyRelation> ? InferRelationsMap<TAllRelations[TTable['_']['name']]> : Record<string, never>;
+/** Infer nested relation fields when TWith has a nested `with` */
+type InferNestedFields<TForeignTable extends AnyTable, TWith extends WithShape, TAllRelations extends RelationsByTable> = TWith extends {
+    with?: infer TW;
+} ? TW extends Record<string, WithShape> ? InferRelationFields<TForeignTable, GetRelationsForTable<TForeignTable, TAllRelations>, TAllRelations, TW> : unknown : unknown;
+/** Recursively build relation fields from a with object */
+type InferRelationFields<TTable extends AnyTable, TRelationsMap extends Record<string, {
+    type: 'one' | 'many';
+    foreignTable: AnyTable;
+}>, TAllRelations extends RelationsByTable, TWith extends Record<string, WithShape>> = {
+    [K in keyof TWith & keyof TRelationsMap]: TWith[K] extends false | undefined ? never : TRelationsMap[K] extends {
+        type: 'one';
+        foreignTable: infer T;
+        optional?: infer O;
+    } ? T extends AnyTable ? ([O] extends [false] ? InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations> : (InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations>) | null) : never : TRelationsMap[K] extends {
+        type: 'many';
+        foreignTable: infer T;
+    } ? T extends AnyTable ? (InferSelectModel<T> & InferNestedFields<T, TWith[K], TAllRelations>)[] : never : never;
+};
+/**
+ * Infer the result type of a select query that includes relations via `.include(with)`.
+ *
+ * Use this to type variables that hold results from relational queries, e.g.:
+ *
+ * @example
+ * ```ts
+ * export type User = InferSelectModel<typeof schema.user>
+ *
+ * const withRelationalObject = { sessions: true, accounts: true } as const
+ * export type UserWithRelations = InferRelationalSelectModel<
+ *   typeof schema.user,
+ *   typeof schema.userRelations,
+ *   typeof withRelationalObject
+ * >
+ * ```
+ *
+ * For nested includes, pass a map of table name -> relations as the fourth parameter:
+ *
+ * @example
+ * ```ts
+ * const withNested = { sessions: { with: { user: true } } } as const
+ * type UserWithSessionsAndUser = InferRelationalSelectModel<
+ *   typeof schema.user,
+ *   typeof schema.userRelations,
+ *   typeof withNested,
+ *   { user: typeof userRelations; session: typeof sessionRelations }
+ * >
+ * ```
+ *
+ * @param TTable - The table type (e.g. typeof schema.user)
+ * @param TRelations - The relations for this table (e.g. typeof schema.userRelations)
+ * @param TWith - The with/include object shape (use `as const` for literal inference)
+ * @param TAllRelations - Optional map of table name -> relations for nested `with` support
+ */
+export type InferRelationalSelectModel<TTable extends AnyTable, TRelations extends Record<string, OneRelation | ManyRelation>, TWith extends Record<string, WithShape>, TAllRelations extends RelationsByTable = {
+    [K in TTable['_']['name']]: TRelations;
+}> = InferSelectModel<TTable> & InferRelationFields<TTable, InferRelationsMap<TRelations>, TAllRelations, TWith>;
+export {};

package/dist/relational-types.js

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