noormme 1.0.0

package/dist/cjs/types/type-generator.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeGenerator = void 0;
+/**
+ * Type generation system that creates TypeScript types from database schema
+ */
+class TypeGenerator {
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    /**
+     * Generate TypeScript types from schema information
+     */
+    generateTypes(schemaInfo) {
+        const entities = [];
+        let interfaces = '';
+        let types = '';
+        // Generate entity types for each table
+        for (const table of schemaInfo.tables) {
+            const entity = this.generateEntityType(table);
+            entities.push(entity);
+            interfaces += entity.interface + '\n\n';
+            types += entity.insertType + '\n\n';
+            types += entity.updateType + '\n\n';
+            types += entity.selectType + '\n\n';
+        }
+        // Add relationship types
+        interfaces += this.generateRelationshipTypes(schemaInfo.relationships);
+        return {
+            entities,
+            interfaces,
+            types
+        };
+    }
+    /**
+     * Generate entity type for a table
+     */
+    generateEntityType(table) {
+        const entityName = this.toPascalCase(table.name);
+        const tableName = table.name;
+        // Generate main entity interface
+        const interfaceCode = this.generateEntityInterface(table, entityName);
+        // Generate insert type (all columns except auto-generated ones)
+        const insertType = this.generateInsertType(table, entityName);
+        // Generate update type (all columns optional except primary key)
+        const updateType = this.generateUpdateType(table, entityName);
+        // Generate select type (all columns as they appear in database)
+        const selectType = this.generateSelectType(table, entityName);
+        return {
+            name: entityName,
+            tableName,
+            interface: interfaceCode,
+            insertType,
+            updateType,
+            selectType
+        };
+    }
+    /**
+     * Generate main entity interface
+     */
+    generateEntityInterface(table, entityName) {
+        let interfaceCode = `export interface ${entityName} {\n`;
+        // Add primary key columns first
+        for (const column of table.columns) {
+            if (column.isPrimaryKey) {
+                const tsType = this.mapColumnToTypeScript(column);
+                const optional = column.nullable ? '?' : '';
+                interfaceCode += `  ${column.name}${optional}: ${tsType}\n`;
+            }
+        }
+        // Add non-primary key columns
+        for (const column of table.columns) {
+            if (!column.isPrimaryKey) {
+                const tsType = this.mapColumnToTypeScript(column);
+                const optional = column.nullable ? '?' : '';
+                interfaceCode += `  ${column.name}${optional}: ${tsType}\n`;
+            }
+        }
+        // Add relationship properties
+        const relationships = this.getRelationshipsForTable(table.name);
+        for (const rel of relationships) {
+            const relType = this.getRelationshipType(rel);
+            interfaceCode += `  ${rel.name}?: ${relType}\n`;
+        }
+        interfaceCode += '}';
+        return interfaceCode;
+    }
+    /**
+     * Generate insert type
+     */
+    generateInsertType(table, entityName) {
+        let insertType = `export type ${entityName}Insert = {\n`;
+        for (const column of table.columns) {
+            // Skip auto-generated columns
+            if (column.isAutoIncrement)
+                continue;
+            const tsType = this.mapColumnToTypeScript(column);
+            const optional = column.nullable || column.defaultValue ? '?' : '';
+            insertType += `  ${column.name}${optional}: ${tsType}\n`;
+        }
+        insertType += '}';
+        return insertType;
+    }
+    /**
+     * Generate update type
+     */
+    generateUpdateType(table, entityName) {
+        let updateType = `export type ${entityName}Update = {\n`;
+        for (const column of table.columns) {
+            const tsType = this.mapColumnToTypeScript(column);
+            const optional = column.isPrimaryKey ? '' : '?';
+            updateType += `  ${column.name}${optional}: ${tsType}\n`;
+        }
+        updateType += '}';
+        return updateType;
+    }
+    /**
+     * Generate select type
+     */
+    generateSelectType(table, entityName) {
+        let selectType = `export type ${entityName}Select = {\n`;
+        for (const column of table.columns) {
+            const tsType = this.mapColumnToTypeScript(column);
+            const optional = column.nullable ? '?' : '';
+            selectType += `  ${column.name}${optional}: ${tsType}\n`;
+        }
+        selectType += '}';
+        return selectType;
+    }
+    /**
+     * Generate relationship types
+     */
+    generateRelationshipTypes(relationships) {
+        let relationshipTypes = '// Relationship types\n';
+        // Group relationships by table
+        const relationshipsByTable = new Map();
+        for (const rel of relationships) {
+            if (!relationshipsByTable.has(rel.fromTable)) {
+                relationshipsByTable.set(rel.fromTable, []);
+            }
+            relationshipsByTable.get(rel.fromTable).push(rel);
+        }
+        for (const [tableName, tableRelationships] of relationshipsByTable) {
+            const entityName = this.toPascalCase(tableName);
+            for (const rel of tableRelationships) {
+                const targetEntityName = this.toPascalCase(rel.toTable);
+                let relType;
+                switch (rel.type) {
+                    case 'one-to-many':
+                        relType = `${targetEntityName}[]`;
+                        break;
+                    case 'many-to-one':
+                        relType = targetEntityName;
+                        break;
+                    case 'many-to-many':
+                        relType = `${targetEntityName}[]`;
+                        break;
+                    default:
+                        relType = targetEntityName;
+                }
+                relationshipTypes += `export type ${entityName}${this.toPascalCase(rel.name)} = ${relType}\n`;
+            }
+        }
+        return relationshipTypes;
+    }
+    /**
+     * Map database column to TypeScript type
+     */
+    mapColumnToTypeScript(column) {
+        // Handle custom type mappings
+        if (this.config.customTypeMappings?.[column.type]) {
+            return this.config.customTypeMappings[column.type];
+        }
+        const typeMapping = {
+            // PostgreSQL types
+            'varchar': 'string',
+            'text': 'string',
+            'char': 'string',
+            'integer': 'number',
+            'bigint': 'number',
+            'smallint': 'number',
+            'decimal': 'number',
+            'numeric': 'number',
+            'real': 'number',
+            'double precision': 'number',
+            'boolean': 'boolean',
+            'date': 'Date',
+            'timestamp': 'Date',
+            'timestamptz': 'Date',
+            'time': 'Date',
+            'json': 'any',
+            'jsonb': 'any',
+            'uuid': 'string',
+            // MySQL specific types
+            'longtext': 'string',
+            'mediumtext': 'string',
+            'tinytext': 'string',
+            'int': 'number',
+            'tinyint': 'number',
+            'float': 'number',
+            'double': 'number',
+            'bool': 'boolean',
+            'datetime': 'Date',
+            // SQLite specific types
+            'blob': 'Buffer',
+            // MSSQL specific types
+            'nvarchar': 'string',
+            'nchar': 'string',
+            'ntext': 'string',
+            'bit': 'boolean',
+            'datetime2': 'Date',
+            'smalldatetime': 'Date'
+        };
+        // Try exact match first
+        if (typeMapping[column.type.toLowerCase()]) {
+            return typeMapping[column.type.toLowerCase()];
+        }
+        // Handle parameterized types (e.g., varchar(255), decimal(10,2))
+        const baseType = column.type.toLowerCase().split('(')[0];
+        if (typeMapping[baseType]) {
+            return typeMapping[baseType];
+        }
+        // Default to any for unknown types
+        return 'any';
+    }
+    /**
+     * Get relationships for a specific table
+     */
+    getRelationshipsForTable(tableName) {
+        // This would be passed from the schema discovery
+        // For now, return empty array
+        return [];
+    }
+    /**
+     * Get relationship type name
+     */
+    getRelationshipType(relationship) {
+        const targetEntityName = this.toPascalCase(relationship.toTable);
+        switch (relationship.type) {
+            case 'one-to-many':
+                return `${targetEntityName}[]`;
+            case 'many-to-one':
+                return targetEntityName;
+            case 'many-to-many':
+                return `${targetEntityName}[]`;
+            default:
+                return targetEntityName;
+        }
+    }
+    /**
+     * Convert string to PascalCase
+     */
+    toPascalCase(str) {
+        return str
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+            .replace(/\s+/g, '')
+            .replace(/[_-]/g, '');
+    }
+}
+exports.TypeGenerator = TypeGenerator;

package/dist/cjs/util/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNotNullOrUndefined<T>(value: T): asserts value is NonNullable<T>;
+export declare function assertIsString(value: any): asserts value is string;

package/dist/cjs/util/assert.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotNullOrUndefined = assertNotNullOrUndefined;
+exports.assertIsString = assertIsString;
+function assertNotNullOrUndefined(value) {
+    if (value === null || value === undefined) {
+        throw new Error(`${value} must not be null or undefined`);
+    }
+}
+function assertIsString(value) {
+    if (typeof value !== 'string') {
+        throw new Error(`${value} must be a string`);
+    }
+}

package/dist/cjs/util/column-type.d.ts

@@ -0,0 +1,175 @@
+import { DrainOuterGeneric } from './type-utils.js';
+/**
+ * This type can be used to specify a different type for
+ * select, insert and update operations.
+ *
+ * Also see the {@link Generated} type.
+ *
+ * ### Examples
+ *
+ * The next example defines a number column that is optional
+ * in inserts and updates. All columns are always optional
+ * in updates so therefore we don't need to specify `undefined`
+ * for the update type. The type below is useful for all kinds of
+ * database generated columns like identifiers. The `Generated`
+ * type is actually just a shortcut for the type in this example:
+ *
+ * ```ts
+ * type GeneratedNumber = ColumnType<number, number | undefined, number>
+ * ```
+ *
+ * The above example makes the column optional in inserts
+ * and updates, but you can still choose to provide the
+ * column. If you want to prevent insertion/update you
+ * can se the type as `never`:
+ *
+ * ```ts
+ * type ReadonlyNumber = ColumnType<number, never, never>
+ * ```
+ *
+ * Here's one more example where the type is different
+ * for each different operation:
+ *
+ * ```ts
+ * type UnupdateableDate = ColumnType<Date, string, never>
+ * ```
+ */
+export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
+    readonly __select__: SelectType;
+    readonly __insert__: InsertType;
+    readonly __update__: UpdateType;
+};
+/**
+ * A shortcut for defining database-generated columns. The type
+ * is the same for all selects, inserts and updates but the
+ * column is optional for inserts and updates.
+ *
+ * The update type is `S` instead of `S | undefined` because updates are always
+ * optional --> no need to specify optionality.
+ * ```
+ */
+export type Generated<S> = ColumnType<S, S | undefined, S>;
+/**
+ * A shortcut for defining columns that are only database-generated
+ * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
+ * is allowed.
+ */
+export type GeneratedAlways<S> = ColumnType<S, never, never>;
+/**
+ * A shortcut for defining JSON columns, which are by default inserted/updated
+ * as stringified JSON strings.
+ */
+export type JSONColumnType<SelectType extends object | null, InsertType = string, UpdateType = string> = ColumnType<SelectType, InsertType, UpdateType>;
+/**
+ * Evaluates to `K` if `T` can be `null` or `undefined`.
+ */
+type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+/**
+ * Evaluates to `K` if `T` can't be `null` or `undefined`.
+ */
+type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
+/**
+ * Evaluates to `K` if `T` isn't `never`.
+ */
+type IfNotNever<T, K> = T extends never ? never : K;
+export type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
+export type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
+export type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
+/**
+ * Keys of `R` whose `InsertType` values can be `null` or `undefined`.
+ */
+export type NullableInsertKeys<R> = {
+    [K in keyof R]: IfNullable<InsertType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `InsertType` values can't be `null` or `undefined`.
+ */
+export type NonNullableInsertKeys<R> = {
+    [K in keyof R]: IfNotNullable<InsertType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `SelectType` values are not `never`
+ */
+type NonNeverSelectKeys<R> = {
+    [K in keyof R]: IfNotNever<SelectType<R[K]>, K>;
+}[keyof R];
+/**
+ * Keys of `R` whose `UpdateType` values are not `never`
+ */
+export type UpdateKeys<R> = {
+    [K in keyof R]: IfNotNever<UpdateType<R[K]>, K>;
+}[keyof R];
+/**
+ * Given a table interface, extracts the select type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type Person = Selectable<PersonTable>
+ * // {
+ * //   id: number,
+ * //   first_name: string
+ * //   modified_at: Date
+ * // }
+ * ```
+ */
+export type Selectable<R> = DrainOuterGeneric<{
+    [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
+}>;
+/**
+ * Given a table interface, extracts the insert type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type InsertablePerson = Insertable<PersonTable>
+ * // {
+ * //   id?: number,
+ * //   first_name: string
+ * //   modified_at: string
+ * // }
+ * ```
+ */
+export type Insertable<R> = DrainOuterGeneric<{
+    [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
+} & {
+    [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
+}>;
+/**
+ * Given a table interface, extracts the update type from all
+ * {@link ColumnType} types.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * interface PersonTable {
+ *   id: Generated<number>
+ *   first_name: string
+ *   modified_at: ColumnType<Date, string, never>
+ * }
+ *
+ * type UpdateablePerson = Updateable<PersonTable>
+ * // {
+ * //   id?: number,
+ * //   first_name?: string
+ * // }
+ * ```
+ */
+export type Updateable<R> = DrainOuterGeneric<{
+    [K in UpdateKeys<R>]?: UpdateType<R[K]>;
+}>;
+export {};

package/dist/cjs/util/column-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/compilable.d.ts

@@ -0,0 +1,5 @@
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+export interface Compilable<O = unknown> {
+    compile(): CompiledQuery<O>;
+}
+export declare function isCompilable(value: unknown): value is Compilable;

package/dist/cjs/util/compilable.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompilable = isCompilable;
+const object_utils_js_1 = require("./object-utils.js");
+function isCompilable(value) {
+    return (0, object_utils_js_1.isObject)(value) && (0, object_utils_js_1.isFunction)(value.compile);
+}

package/dist/cjs/util/deferred.d.ts

@@ -0,0 +1,7 @@
+export declare class Deferred<T> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/dist/cjs/util/deferred.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = void 0;
+class Deferred {
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#promise = new Promise((resolve, reject) => {
+            this.#reject = reject;
+            this.#resolve = resolve;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve = (value) => {
+        if (this.#resolve) {
+            this.#resolve(value);
+        }
+    };
+    reject = (reason) => {
+        if (this.#reject) {
+            this.#reject(reason);
+        }
+    };
+}
+exports.Deferred = Deferred;

package/dist/cjs/util/explainable.d.ts

@@ -0,0 +1,40 @@
+import { Expression } from '../expression/expression.js';
+export type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export interface Explainable {
+    /**
+     * Executes query with `explain` statement before the main query.
+     *
+     * ```ts
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json select * from `person` where `gender` = ?
+     * ```
+     *
+     * You can also execute `explain analyze` statements.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json', sql`analyze`)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * explain (analyze, format json) select * from "person" where "gender" = $1
+     * ```
+     */
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<O[]>;
+}

package/dist/cjs/util/explainable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/infer-result.d.ts

@@ -0,0 +1,48 @@
+import { DeleteResult } from '../query-builder/delete-result.js';
+import { InsertResult } from '../query-builder/insert-result.js';
+import { MergeResult } from '../query-builder/merge-result.js';
+import { UpdateResult } from '../query-builder/update-result.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from './compilable.js';
+import { Simplify } from './type-utils.js';
+/**
+ * A helper type that allows inferring a select/insert/update/delete query's result
+ * type from a query builder or compiled query.
+ *
+ * ### Examples
+ *
+ * Infer a query builder's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const query = db
+ *   .selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select(['person.first_name', 'pet.name'])
+ *
+ * type QueryResult = InferResult<typeof query> // { first_name: string; name: string; }[]
+ * ```
+ *
+ * Infer a compiled query's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const compiledQuery = db
+ *   .insertInto('person')
+ *   .values({
+ *     first_name: 'Foo',
+ *     last_name: 'Barson',
+ *     gender: 'other',
+ *     age: 15,
+ *   })
+ *   .returningAll()
+ *   .compile()
+ *
+ * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
+ * ```
+ */
+export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O[] : Simplify<O>[];
+export {};

package/dist/cjs/util/infer-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/json-object-args.d.ts

@@ -0,0 +1,3 @@
+import { Expression } from '../expression/expression.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+export declare function getJsonObjectArgs(node: SelectQueryNode, table: string): Expression<unknown>[];

package/dist/cjs/util/json-object-args.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonObjectArgs = getJsonObjectArgs;
+const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const reference_node_js_1 = require("../operation-node/reference-node.js");
+const table_node_js_1 = require("../operation-node/table-node.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (reference_node_js_1.ReferenceNode.is(s) && column_node_js_1.ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (column_node_js_1.ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (alias_node_js_1.AliasNode.is(s) && identifier_node_js_1.IdentifierNode.is(s.alias)) {
+            args.push(colName(s.alias.name), colRef(table, s.alias.name));
+        }
+        else {
+            throw new Error(`can't extract column names from the select query node`);
+        }
+    }
+    return args;
+}
+function colName(col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new expression_wrapper_js_1.ExpressionWrapper(reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(col), table_node_js_1.TableNode.create(table)));
+}

package/dist/cjs/util/log-once.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+export declare function logOnce(message: string): void;

package/dist/cjs/util/log-once.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logOnce = logOnce;
+const LOGGED_MESSAGES = new Set();
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+function logOnce(message) {
+    if (LOGGED_MESSAGES.has(message)) {
+        return;
+    }
+    LOGGED_MESSAGES.add(message);
+    console.log(message);
+}