kysely 0.12.2 → 0.15.0

package/dist/cjs/migration/migration.js

@@ -1,187 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationModule = exports.MIGRATION_LOCK_ID = exports.MIGRATION_LOCK_TABLE = exports.MIGRATION_TABLE = void 0;
-const path = require("path");
-const fs_1 = require("fs");
-const object_utils_js_1 = require("../util/object-utils.js");
-exports.MIGRATION_TABLE = 'kysely_migration';
-exports.MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
-exports.MIGRATION_LOCK_ID = 'migration_lock';
-class MigrationModule {
-    #db;
-    #adapter;
-    constructor(db, adapter) {
-        this.#db = db;
-        this.#adapter = adapter;
-    }
-    async migrateToLatest(migrationsOrFolderPath) {
-        await ensureMigrationTablesExists(this.#db);
-        const allMigrations = await this.#getAllMigrations(migrationsOrFolderPath);
-        await this.#migrateToLatest(allMigrations);
-    }
-    async #getAllMigrations(migrationsOrFolderPath) {
-        return (0, object_utils_js_1.isString)(migrationsOrFolderPath)
-            ? await readMigrationsFromFolder(migrationsOrFolderPath)
-            : migrationsOrFolderPath;
-    }
-    async #migrateToLatest(allMigrations) {
-        const run = async (db) => {
-            try {
-                await this.#adapter.acquireMigrationLock(db);
-                await runNewMigrations(db, allMigrations);
-            }
-            finally {
-                await this.#adapter.releaseMigrationLock(db);
-            }
-        };
-        if (this.#adapter.supportsTransactionalDdl) {
-            await this.#db.transaction().execute(run);
-        }
-        else {
-            await this.#db.connection().execute(run);
-        }
-    }
-}
-exports.MigrationModule = MigrationModule;
-async function ensureMigrationTablesExists(db) {
-    await ensureMigrationTableExists(db);
-    await ensureMigrationLockTableExists(db);
-    await ensureLockRowExists(db);
-}
-async function ensureMigrationTableExists(db) {
-    if (!(await doesTableExists(db, exports.MIGRATION_TABLE))) {
-        try {
-            await db.schema
-                .createTable(exports.MIGRATION_TABLE)
-                .ifNotExists()
-                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                // The migration run time as ISO string. This is not a real date type as we
-                // can't know which data type is supported by all future dialects.
-                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
-                .execute();
-        }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, exports.MIGRATION_TABLE))) {
-                throw error;
-            }
-        }
-    }
-}
-async function ensureMigrationLockTableExists(db) {
-    if (!(await doesTableExists(db, exports.MIGRATION_LOCK_TABLE))) {
-        try {
-            await db.schema
-                .createTable(exports.MIGRATION_LOCK_TABLE)
-                .ifNotExists()
-                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
-                .execute();
-        }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, exports.MIGRATION_LOCK_TABLE))) {
-                throw error;
-            }
-        }
-    }
-}
-async function ensureLockRowExists(db) {
-    if (!(await doesLockRowExists(db))) {
-        try {
-            await db
-                .insertInto(exports.MIGRATION_LOCK_TABLE)
-                .values({ id: exports.MIGRATION_LOCK_ID })
-                .execute();
-        }
-        catch (error) {
-            if (!(await doesLockRowExists(db))) {
-                throw error;
-            }
-        }
-    }
-}
-async function doesTableExists(db, tableName) {
-    const metadata = await db.introspection.getMetadata({
-        withInternalKyselyTables: true,
-    });
-    return !!metadata.tables.find((it) => it.name === tableName);
-}
-async function doesLockRowExists(db) {
-    const lockRow = await db
-        .selectFrom(exports.MIGRATION_LOCK_TABLE)
-        .where('id', '=', exports.MIGRATION_LOCK_ID)
-        .select('id')
-        .executeTakeFirst();
-    return !!lockRow;
-}
-async function readMigrationsFromFolder(migrationsFolderPath) {
-    const files = await fs_1.promises.readdir(migrationsFolderPath);
-    const migrations = {};
-    for (const file of files) {
-        if ((file.endsWith('.js') || file.endsWith('.ts')) &&
-            !file.endsWith('.d.ts')) {
-            const migration = await Promise.resolve().then(() => require(path.join(migrationsFolderPath, file)));
-            if (isMigration(migration)) {
-                migrations[file.substring(0, file.length - 3)] = migration;
-            }
-        }
-    }
-    return migrations;
-}
-async function runNewMigrations(db, allMigrations) {
-    const sortedMigrations = Object.keys(allMigrations)
-        .sort()
-        .map((name) => ({
-        ...allMigrations[name],
-        name,
-    }));
-    const executedMigrations = await db
-        .selectFrom(exports.MIGRATION_TABLE)
-        .select('name')
-        .orderBy('name')
-        .execute();
-    const lastExecuted = (0, object_utils_js_1.getLast)(executedMigrations);
-    const lastExecutedIndex = sortedMigrations.findIndex((it) => it.name === lastExecuted?.name);
-    if (lastExecuted && lastExecutedIndex === -1) {
-        throw new Error(`corrupted migrations: previously executed migration ${lastExecuted.name} is missing`);
-    }
-    const oldMigrations = lastExecuted
-        ? sortedMigrations.slice(0, lastExecutedIndex + 1)
-        : [];
-    const newMigrations = lastExecuted
-        ? sortedMigrations.slice(lastExecutedIndex + 1)
-        : sortedMigrations;
-    ensureMigrationsAreNotCorrupted(executedMigrations.map((it) => it.name), oldMigrations.map((it) => it.name));
-    for (const migration of newMigrations) {
-        await migration.up(db);
-        await db
-            .insertInto(exports.MIGRATION_TABLE)
-            .values({
-            name: migration.name,
-            timestamp: new Date().toISOString(),
-        })
-            .execute();
-    }
-}
-function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNames) {
-    const executedSet = new Set(executedMigrationNames);
-    const oldMigrationSet = new Set(oldMigrationNames);
-    for (const it of executedSet) {
-        if (!oldMigrationSet.has(it)) {
-            throw new Error(`corrupted migrations: previously executed migration ${it} is missing`);
-        }
-    }
-    for (const it of oldMigrationSet) {
-        if (!executedSet.has(it)) {
-            throw new Error(`corrupted migrations: new migration ${it} comes alphabetically before the last executed migration. New migrations must always have a name that comes alphabetically after the last executed migration.`);
-        }
-    }
-}
-function isMigration(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && (0, object_utils_js_1.isFunction)(obj.up);
-}

package/dist/cjs/operation-node/generated-always-as-node.d.ts

@@ -1,16 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
-export interface GeneratedAlwaysAsNode extends OperationNode {
-    readonly kind: 'GeneratedAlwaysAsNode';
-    readonly expression: RawNode;
-    readonly stored?: boolean;
-}
-/**
- * @internal
- */
-export declare const GeneratedAlwaysAsNode: Readonly<{
-    is(node: OperationNode): node is GeneratedAlwaysAsNode;
-    create(expression: string): GeneratedAlwaysAsNode;
-    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
-}>;

package/dist/cjs/operation-node/generated-always-as-node.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeneratedAlwaysAsNode = void 0;
-const object_utils_js_1 = require("../util/object-utils.js");
-const raw_node_js_1 = require("./raw-node.js");
-/**
- * @internal
- */
-exports.GeneratedAlwaysAsNode = (0, object_utils_js_1.freeze)({
-    is(node) {
-        return node.kind === 'GeneratedAlwaysAsNode';
-    },
-    create(expression) {
-        return (0, object_utils_js_1.freeze)({
-            kind: 'GeneratedAlwaysAsNode',
-            expression: raw_node_js_1.RawNode.createWithSql(expression),
-        });
-    },
-    cloneWith(node, params) {
-        return (0, object_utils_js_1.freeze)({
-            ...node,
-            ...params,
-        });
-    },
-});

package/dist/cjs/parser/on-conflict-parser.d.ts

@@ -1,10 +0,0 @@
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { AnyColumn } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.js';
-import { MutationObject } from './update-set-parser.js';
-export declare type OnConflictConstraintTarget = {
-    constraint: string;
-};
-export declare type OnConflictTargetExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | ReadonlyArray<AnyColumn<DB, TB>> | OnConflictConstraintTarget;
-export declare function parseOnConflictDoNothing(target: OnConflictTargetExpression<any, any>): OnConflictNode;
-export declare function parseOnConflictUpdate(ctx: ParseContext, target: OnConflictTargetExpression<any, any>, updates: MutationObject<any, any>): OnConflictNode;

package/dist/cjs/parser/on-conflict-parser.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOnConflictUpdate = exports.parseOnConflictDoNothing = void 0;
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
-const object_utils_js_1 = require("../util/object-utils.js");
-const reference_parser_js_1 = require("./reference-parser.js");
-const update_set_parser_js_1 = require("./update-set-parser.js");
-function parseOnConflictDoNothing(target) {
-    return on_conflict_node_js_1.OnConflictNode.create({
-        ...parseConflictTarget(target),
-        doNothing: true,
-    });
-}
-exports.parseOnConflictDoNothing = parseOnConflictDoNothing;
-function parseOnConflictUpdate(ctx, target, updates) {
-    return on_conflict_node_js_1.OnConflictNode.create({
-        ...parseConflictTarget(target),
-        updates: (0, update_set_parser_js_1.parseUpdateObject)(ctx, updates),
-    });
-}
-exports.parseOnConflictUpdate = parseOnConflictUpdate;
-function parseConflictTarget(target) {
-    if ((0, object_utils_js_1.isString)(target) || (0, object_utils_js_1.isReadonlyArray)(target)) {
-        return {
-            columns: (0, object_utils_js_1.asReadonlyArray)(target).map(reference_parser_js_1.parseColumnName),
-        };
-    }
-    if ((0, object_utils_js_1.isObject)(target) && !(0, object_utils_js_1.isReadonlyArray)(target)) {
-        return {
-            constraint: identifier_node_js_1.IdentifierNode.create(target.constraint),
-        };
-    }
-    throw new Error(`invalid on conflict target ${JSON.stringify(target)}`);
-}

package/dist/cjs/util/generated-placeholder.d.ts

@@ -1,3 +0,0 @@
-import { GeneratedPlaceholder } from './type-utils.js';
-export declare const GENERATED_PLACEHOLDER: GeneratedPlaceholder;
-export declare function isGeneratedPlaceholder(obj: unknown): obj is GeneratedPlaceholder;

package/dist/cjs/util/generated-placeholder.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGeneratedPlaceholder = exports.GENERATED_PLACEHOLDER = void 0;
-const object_utils_js_1 = require("./object-utils.js");
-exports.GENERATED_PLACEHOLDER = (0, object_utils_js_1.freeze)({
-    __isGeneratedPlaceholder__: true,
-});
-function isGeneratedPlaceholder(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && obj.__isGeneratedPlaceholder__ === true;
-}
-exports.isGeneratedPlaceholder = isGeneratedPlaceholder;

package/dist/esm/migration/migration.d.ts

@@ -1,66 +0,0 @@
-import { Kysely } from '../kysely.js';
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
-export declare const MIGRATION_TABLE = "kysely_migration";
-export declare const MIGRATION_LOCK_TABLE = "kysely_migration_lock";
-export declare const MIGRATION_LOCK_ID = "migration_lock";
-export declare class MigrationModule {
-    #private;
-    constructor(db: Kysely<any>, adapter: DialectAdapter);
-    /**
-     * Runs all migrations that have not yet been run.
-     *
-     * The only argument must either be a file path to the folder that contains all migrations
-     * OR an object that contains all migrations (not just the ones that need to be run).
-     * The keys in the object must be the unique migration names.
-     *
-     * This method goes through all possible migrations (passed as the argument) and runs the
-     * ones whose names are alphabetically after the last migration that has been run. If the
-     * list of executed migrations doesn't match the list of possible migrations, and error
-     * is thrown.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * await db.migration.migrateToLatest(
-     *   path.join(__dirname, 'migrations')
-     * )
-     * ```
-     *
-     * In the next example, we use a record of migration objects instead of file folder path.
-     * The keys in the object are migration names that can be anything you want. The order of
-     * the migrations is determined based on the alphabetical order of the keys in the record.
-     * This can be useful if you are using a bundler like webpack or esbuild.
-     *
-     * ```ts
-     * await db.migration.migrateToLatest({
-     *   migration1: {
-     *     async up(db: Kysely<any>): Promise<void> {
-     *       ...
-     *     },
-     *
-     *     async down(db: Kysely<any>): Promise<void> {
-     *       ...
-     *     }
-     *   },
-     *
-     *   migration2: {
-     *     async up(db: Kysely<any>): Promise<void> {
-     *       ...
-     *     },
-     *
-     *     async down(db: Kysely<any>): Promise<void> {
-     *       ...
-     *     }
-     *   },
-     *
-     *  ...
-     * })
-     * ```
-     */
-    migrateToLatest(migrationsFolderPath: string): Promise<void>;
-    migrateToLatest(allMigrations: Record<string, Migration>): Promise<void>;
-}
-export interface Migration {
-    up(db: Kysely<any>): Promise<void>;
-    down?(db: Kysely<any>): Promise<void>;
-}

package/dist/esm/migration/migration.js

@@ -1,183 +0,0 @@
-import * as path from 'path';
-import { promises as fs } from 'fs';
-import { getLast, isFunction, isObject, isString, } from '../util/object-utils.js';
-export const MIGRATION_TABLE = 'kysely_migration';
-export const MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
-export const MIGRATION_LOCK_ID = 'migration_lock';
-export class MigrationModule {
-    #db;
-    #adapter;
-    constructor(db, adapter) {
-        this.#db = db;
-        this.#adapter = adapter;
-    }
-    async migrateToLatest(migrationsOrFolderPath) {
-        await ensureMigrationTablesExists(this.#db);
-        const allMigrations = await this.#getAllMigrations(migrationsOrFolderPath);
-        await this.#migrateToLatest(allMigrations);
-    }
-    async #getAllMigrations(migrationsOrFolderPath) {
-        return isString(migrationsOrFolderPath)
-            ? await readMigrationsFromFolder(migrationsOrFolderPath)
-            : migrationsOrFolderPath;
-    }
-    async #migrateToLatest(allMigrations) {
-        const run = async (db) => {
-            try {
-                await this.#adapter.acquireMigrationLock(db);
-                await runNewMigrations(db, allMigrations);
-            }
-            finally {
-                await this.#adapter.releaseMigrationLock(db);
-            }
-        };
-        if (this.#adapter.supportsTransactionalDdl) {
-            await this.#db.transaction().execute(run);
-        }
-        else {
-            await this.#db.connection().execute(run);
-        }
-    }
-}
-async function ensureMigrationTablesExists(db) {
-    await ensureMigrationTableExists(db);
-    await ensureMigrationLockTableExists(db);
-    await ensureLockRowExists(db);
-}
-async function ensureMigrationTableExists(db) {
-    if (!(await doesTableExists(db, MIGRATION_TABLE))) {
-        try {
-            await db.schema
-                .createTable(MIGRATION_TABLE)
-                .ifNotExists()
-                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                // The migration run time as ISO string. This is not a real date type as we
-                // can't know which data type is supported by all future dialects.
-                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
-                .execute();
-        }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, MIGRATION_TABLE))) {
-                throw error;
-            }
-        }
-    }
-}
-async function ensureMigrationLockTableExists(db) {
-    if (!(await doesTableExists(db, MIGRATION_LOCK_TABLE))) {
-        try {
-            await db.schema
-                .createTable(MIGRATION_LOCK_TABLE)
-                .ifNotExists()
-                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
-                .execute();
-        }
-        catch (error) {
-            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-            // query doesn't throw if the table already exits. That's why we check if
-            // the table exist here and ignore the error if it does.
-            if (!(await doesTableExists(db, MIGRATION_LOCK_TABLE))) {
-                throw error;
-            }
-        }
-    }
-}
-async function ensureLockRowExists(db) {
-    if (!(await doesLockRowExists(db))) {
-        try {
-            await db
-                .insertInto(MIGRATION_LOCK_TABLE)
-                .values({ id: MIGRATION_LOCK_ID })
-                .execute();
-        }
-        catch (error) {
-            if (!(await doesLockRowExists(db))) {
-                throw error;
-            }
-        }
-    }
-}
-async function doesTableExists(db, tableName) {
-    const metadata = await db.introspection.getMetadata({
-        withInternalKyselyTables: true,
-    });
-    return !!metadata.tables.find((it) => it.name === tableName);
-}
-async function doesLockRowExists(db) {
-    const lockRow = await db
-        .selectFrom(MIGRATION_LOCK_TABLE)
-        .where('id', '=', MIGRATION_LOCK_ID)
-        .select('id')
-        .executeTakeFirst();
-    return !!lockRow;
-}
-async function readMigrationsFromFolder(migrationsFolderPath) {
-    const files = await fs.readdir(migrationsFolderPath);
-    const migrations = {};
-    for (const file of files) {
-        if ((file.endsWith('.js') || file.endsWith('.ts')) &&
-            !file.endsWith('.d.ts')) {
-            const migration = await import(path.join(migrationsFolderPath, file));
-            if (isMigration(migration)) {
-                migrations[file.substring(0, file.length - 3)] = migration;
-            }
-        }
-    }
-    return migrations;
-}
-async function runNewMigrations(db, allMigrations) {
-    const sortedMigrations = Object.keys(allMigrations)
-        .sort()
-        .map((name) => ({
-        ...allMigrations[name],
-        name,
-    }));
-    const executedMigrations = await db
-        .selectFrom(MIGRATION_TABLE)
-        .select('name')
-        .orderBy('name')
-        .execute();
-    const lastExecuted = getLast(executedMigrations);
-    const lastExecutedIndex = sortedMigrations.findIndex((it) => it.name === lastExecuted?.name);
-    if (lastExecuted && lastExecutedIndex === -1) {
-        throw new Error(`corrupted migrations: previously executed migration ${lastExecuted.name} is missing`);
-    }
-    const oldMigrations = lastExecuted
-        ? sortedMigrations.slice(0, lastExecutedIndex + 1)
-        : [];
-    const newMigrations = lastExecuted
-        ? sortedMigrations.slice(lastExecutedIndex + 1)
-        : sortedMigrations;
-    ensureMigrationsAreNotCorrupted(executedMigrations.map((it) => it.name), oldMigrations.map((it) => it.name));
-    for (const migration of newMigrations) {
-        await migration.up(db);
-        await db
-            .insertInto(MIGRATION_TABLE)
-            .values({
-            name: migration.name,
-            timestamp: new Date().toISOString(),
-        })
-            .execute();
-    }
-}
-function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNames) {
-    const executedSet = new Set(executedMigrationNames);
-    const oldMigrationSet = new Set(oldMigrationNames);
-    for (const it of executedSet) {
-        if (!oldMigrationSet.has(it)) {
-            throw new Error(`corrupted migrations: previously executed migration ${it} is missing`);
-        }
-    }
-    for (const it of oldMigrationSet) {
-        if (!executedSet.has(it)) {
-            throw new Error(`corrupted migrations: new migration ${it} comes alphabetically before the last executed migration. New migrations must always have a name that comes alphabetically after the last executed migration.`);
-        }
-    }
-}
-function isMigration(obj) {
-    return isObject(obj) && isFunction(obj.up);
-}

package/dist/esm/operation-node/generated-always-as-node.d.ts

@@ -1,16 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
-export interface GeneratedAlwaysAsNode extends OperationNode {
-    readonly kind: 'GeneratedAlwaysAsNode';
-    readonly expression: RawNode;
-    readonly stored?: boolean;
-}
-/**
- * @internal
- */
-export declare const GeneratedAlwaysAsNode: Readonly<{
-    is(node: OperationNode): node is GeneratedAlwaysAsNode;
-    create(expression: string): GeneratedAlwaysAsNode;
-    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
-}>;

package/dist/esm/operation-node/generated-always-as-node.js

@@ -1,22 +0,0 @@
-import { freeze } from '../util/object-utils.js';
-import { RawNode } from './raw-node.js';
-/**
- * @internal
- */
-export const GeneratedAlwaysAsNode = freeze({
-    is(node) {
-        return node.kind === 'GeneratedAlwaysAsNode';
-    },
-    create(expression) {
-        return freeze({
-            kind: 'GeneratedAlwaysAsNode',
-            expression: RawNode.createWithSql(expression),
-        });
-    },
-    cloneWith(node, params) {
-        return freeze({
-            ...node,
-            ...params,
-        });
-    },
-});

package/dist/esm/parser/on-conflict-parser.d.ts

@@ -1,10 +0,0 @@
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { AnyColumn } from '../util/type-utils.js';
-import { ParseContext } from './parse-context.js';
-import { MutationObject } from './update-set-parser.js';
-export declare type OnConflictConstraintTarget = {
-    constraint: string;
-};
-export declare type OnConflictTargetExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | ReadonlyArray<AnyColumn<DB, TB>> | OnConflictConstraintTarget;
-export declare function parseOnConflictDoNothing(target: OnConflictTargetExpression<any, any>): OnConflictNode;
-export declare function parseOnConflictUpdate(ctx: ParseContext, target: OnConflictTargetExpression<any, any>, updates: MutationObject<any, any>): OnConflictNode;

package/dist/esm/parser/on-conflict-parser.js

@@ -1,30 +0,0 @@
-import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { OnConflictNode } from '../operation-node/on-conflict-node.js';
-import { asReadonlyArray, isObject, isReadonlyArray, isString, } from '../util/object-utils.js';
-import { parseColumnName } from './reference-parser.js';
-import { parseUpdateObject } from './update-set-parser.js';
-export function parseOnConflictDoNothing(target) {
-    return OnConflictNode.create({
-        ...parseConflictTarget(target),
-        doNothing: true,
-    });
-}
-export function parseOnConflictUpdate(ctx, target, updates) {
-    return OnConflictNode.create({
-        ...parseConflictTarget(target),
-        updates: parseUpdateObject(ctx, updates),
-    });
-}
-function parseConflictTarget(target) {
-    if (isString(target) || isReadonlyArray(target)) {
-        return {
-            columns: asReadonlyArray(target).map(parseColumnName),
-        };
-    }
-    if (isObject(target) && !isReadonlyArray(target)) {
-        return {
-            constraint: IdentifierNode.create(target.constraint),
-        };
-    }
-    throw new Error(`invalid on conflict target ${JSON.stringify(target)}`);
-}

package/dist/esm/util/generated-placeholder.d.ts

@@ -1,3 +0,0 @@
-import { GeneratedPlaceholder } from './type-utils.js';
-export declare const GENERATED_PLACEHOLDER: GeneratedPlaceholder;
-export declare function isGeneratedPlaceholder(obj: unknown): obj is GeneratedPlaceholder;

package/dist/esm/util/generated-placeholder.js

@@ -1,7 +0,0 @@
-import { freeze, isObject } from './object-utils.js';
-export const GENERATED_PLACEHOLDER = freeze({
-    __isGeneratedPlaceholder__: true,
-});
-export function isGeneratedPlaceholder(obj) {
-    return isObject(obj) && obj.__isGeneratedPlaceholder__ === true;
-}