kysely 0.28.17 → 0.29.0

package/dist/esm/operation-node/alias-node.d.ts

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface AliasNode extends OperationNode {
-    readonly kind: 'AliasNode';
-    readonly node: OperationNode;
-    readonly alias: OperationNode;
-}
-type AliasNodeFactory = Readonly<{
-    is(node: OperationNode): node is AliasNode;
-    create(node: OperationNode, alias: OperationNode): Readonly<AliasNode>;
-}>;
-/**
- * @internal
- */
-export declare const AliasNode: AliasNodeFactory;
-export {};

package/dist/esm/operation-node/alter-column-node.d.ts

@@ -1,23 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import { ColumnNode } from './column-node.js';
-import type { RawNode } from './raw-node.js';
-export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
-export interface AlterColumnNode extends OperationNode {
-    readonly kind: 'AlterColumnNode';
-    readonly column: ColumnNode;
-    readonly dataType?: OperationNode;
-    readonly dataTypeExpression?: RawNode;
-    readonly setDefault?: OperationNode;
-    readonly dropDefault?: true;
-    readonly setNotNull?: true;
-    readonly dropNotNull?: true;
-}
-type AlterColumnNodeFactory = Readonly<{
-    is(node: OperationNode): node is AlterColumnNode;
-    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): Readonly<AlterColumnNode>;
-}>;
-/**
- * @internal
- */
-export declare const AlterColumnNode: AlterColumnNodeFactory;
-export {};

package/dist/esm/operation-node/alter-table-node.d.ts

@@ -1,38 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import type { AddColumnNode } from './add-column-node.js';
-import type { DropColumnNode } from './drop-column-node.js';
-import type { TableNode } from './table-node.js';
-import type { IdentifierNode } from './identifier-node.js';
-import type { RenameColumnNode } from './rename-column-node.js';
-import type { AlterColumnNode } from './alter-column-node.js';
-import type { AddConstraintNode } from './add-constraint-node.js';
-import type { DropConstraintNode } from './drop-constraint-node.js';
-import type { ModifyColumnNode } from './modify-column-node.js';
-import type { DropIndexNode } from './drop-index-node.js';
-import type { AddIndexNode } from './add-index-node.js';
-import type { RenameConstraintNode } from './rename-constraint-node.js';
-export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
-export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
-export interface AlterTableNode extends OperationNode {
-    readonly kind: 'AlterTableNode';
-    readonly table: TableNode;
-    readonly renameTo?: TableNode;
-    readonly setSchema?: IdentifierNode;
-    readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
-    readonly addConstraint?: AddConstraintNode;
-    readonly dropConstraint?: DropConstraintNode;
-    readonly renameConstraint?: RenameConstraintNode;
-    readonly addIndex?: AddIndexNode;
-    readonly dropIndex?: DropIndexNode;
-}
-type AlterTableNodeFactory = Readonly<{
-    is(node: OperationNode): node is AlterTableNode;
-    create(table: TableNode): Readonly<AlterTableNode>;
-    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): Readonly<AlterTableNode>;
-    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): Readonly<AlterTableNode>;
-}>;
-/**
- * @internal
- */
-export declare const AlterTableNode: AlterTableNodeFactory;
-export {};

package/dist/esm/operation-node/and-node.d.ts

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface AndNode extends OperationNode {
-    readonly kind: 'AndNode';
-    readonly left: OperationNode;
-    readonly right: OperationNode;
-}
-type AndNodeFactory = Readonly<{
-    is(node: OperationNode): node is AndNode;
-    create(left: OperationNode, right: OperationNode): Readonly<AndNode>;
-}>;
-/**
- * @internal
- */
-export declare const AndNode: AndNodeFactory;
-export {};

package/dist/esm/operation-node/binary-operation-node.d.ts

@@ -1,16 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface BinaryOperationNode extends OperationNode {
-    readonly kind: 'BinaryOperationNode';
-    readonly leftOperand: OperationNode;
-    readonly operator: OperationNode;
-    readonly rightOperand: OperationNode;
-}
-type BinaryOperationNodeFactory = Readonly<{
-    is(node: OperationNode): node is BinaryOperationNode;
-    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): Readonly<BinaryOperationNode>;
-}>;
-/**
- * @internal
- */
-export declare const BinaryOperationNode: BinaryOperationNodeFactory;
-export {};

package/dist/esm/operation-node/case-node.d.ts

@@ -1,21 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import { WhenNode } from './when-node.js';
-export interface CaseNode extends OperationNode {
-    readonly kind: 'CaseNode';
-    readonly value?: OperationNode;
-    readonly when?: ReadonlyArray<WhenNode>;
-    readonly else?: OperationNode;
-    readonly isStatement?: boolean;
-}
-type CaseNodeFactory = Readonly<{
-    is(node: OperationNode): node is CaseNode;
-    create(value?: OperationNode): Readonly<CaseNode>;
-    cloneWithWhen(caseNode: CaseNode, when: WhenNode): Readonly<CaseNode>;
-    cloneWithThen(caseNode: CaseNode, then: OperationNode): Readonly<CaseNode>;
-    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): Readonly<CaseNode>;
-}>;
-/**
- * @internal
- */
-export declare const CaseNode: CaseNodeFactory;
-export {};

package/dist/esm/operation-node/cast-node.d.ts

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface CastNode extends OperationNode {
-    readonly kind: 'CastNode';
-    readonly expression: OperationNode;
-    readonly dataType: OperationNode;
-}
-type CastNodeFactory = Readonly<{
-    is(node: OperationNode): node is CastNode;
-    create(expression: OperationNode, dataType: OperationNode): Readonly<CastNode>;
-}>;
-/**
- * @internal
- */
-export declare const CastNode: CastNodeFactory;
-export {};

package/dist/esm/operation-node/check-constraint-node.d.ts

@@ -1,16 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import { IdentifierNode } from './identifier-node.js';
-export interface CheckConstraintNode extends OperationNode {
-    readonly kind: 'CheckConstraintNode';
-    readonly expression: OperationNode;
-    readonly name?: IdentifierNode;
-}
-type CheckConstraintNodeFactory = Readonly<{
-    is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: OperationNode, constraintName?: string): Readonly<CheckConstraintNode>;
-}>;
-/**
- * @internal
- */
-export declare const CheckConstraintNode: CheckConstraintNodeFactory;
-export {};

package/dist/esm/operation-node/collate-node.d.ts

@@ -1,15 +0,0 @@
-import { IdentifierNode } from './identifier-node.js';
-import type { OperationNode } from './operation-node.js';
-export interface CollateNode extends OperationNode {
-    readonly kind: 'CollateNode';
-    readonly collation: IdentifierNode;
-}
-type CollateNodeFactory = Readonly<{
-    is(node: OperationNode): node is CollateNode;
-    create(collation: string): Readonly<CollateNode>;
-}>;
-/**
- * @internal
- */
-export declare const CollateNode: CollateNodeFactory;
-export {};

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -1,38 +0,0 @@
-import type { CheckConstraintNode } from './check-constraint-node.js';
-import { ColumnNode } from './column-node.js';
-import type { DefaultValueNode } from './default-value-node.js';
-import type { GeneratedNode } from './generated-node.js';
-import type { OperationNode } from './operation-node.js';
-import type { ReferencesNode } from './references-node.js';
-export type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
-export interface ColumnDefinitionNode extends OperationNode {
-    readonly kind: 'ColumnDefinitionNode';
-    readonly column: ColumnNode;
-    readonly dataType: OperationNode;
-    readonly references?: ReferencesNode;
-    readonly primaryKey?: boolean;
-    readonly autoIncrement?: boolean;
-    readonly unique?: boolean;
-    readonly notNull?: boolean;
-    readonly defaultTo?: DefaultValueNode;
-    readonly check?: CheckConstraintNode;
-    readonly generated?: GeneratedNode;
-    readonly unsigned?: boolean;
-    readonly frontModifiers?: ReadonlyArray<OperationNode>;
-    readonly endModifiers?: ReadonlyArray<OperationNode>;
-    readonly nullsNotDistinct?: boolean;
-    readonly identity?: boolean;
-    readonly ifNotExists?: boolean;
-}
-type ColumnDefinitionNodeFactory = Readonly<{
-    is(node: OperationNode): node is ColumnDefinitionNode;
-    create(column: string, dataType: OperationNode): Readonly<ColumnDefinitionNode>;
-    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
-    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): Readonly<ColumnDefinitionNode>;
-    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): Readonly<ColumnDefinitionNode>;
-}>;
-/**
- * @internal
- */
-export declare const ColumnDefinitionNode: ColumnDefinitionNodeFactory;
-export {};

package/dist/esm/operation-node/column-node.d.ts

@@ -1,15 +0,0 @@
-import { IdentifierNode } from './identifier-node.js';
-import type { OperationNode } from './operation-node.js';
-export interface ColumnNode extends OperationNode {
-    readonly kind: 'ColumnNode';
-    readonly column: IdentifierNode;
-}
-type ColumnNodeFactory = Readonly<{
-    is(node: OperationNode): node is ColumnNode;
-    create(column: string): Readonly<ColumnNode>;
-}>;
-/**
- * @internal
- */
-export declare const ColumnNode: ColumnNodeFactory;
-export {};

package/dist/esm/operation-node/column-update-node.d.ts

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface ColumnUpdateNode extends OperationNode {
-    readonly kind: 'ColumnUpdateNode';
-    readonly column: OperationNode;
-    readonly value: OperationNode;
-}
-type ColumnUpdateNodeFactory = Readonly<{
-    is(node: OperationNode): node is ColumnUpdateNode;
-    create(column: OperationNode, value: OperationNode): Readonly<ColumnUpdateNode>;
-}>;
-/**
- * @internal
- */
-export declare const ColumnUpdateNode: ColumnUpdateNodeFactory;
-export {};

package/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -1,17 +0,0 @@
-import { ColumnNode } from './column-node.js';
-import type { OperationNode } from './operation-node.js';
-import { TableNode } from './table-node.js';
-export interface CommonTableExpressionNameNode extends OperationNode {
-    readonly kind: 'CommonTableExpressionNameNode';
-    readonly table: TableNode;
-    readonly columns?: ReadonlyArray<ColumnNode>;
-}
-type CommonTableExpressionNameNodeFactory = Readonly<{
-    is(node: OperationNode): node is CommonTableExpressionNameNode;
-    create(tableName: string, columnNames?: ReadonlyArray<string>): Readonly<CommonTableExpressionNameNode>;
-}>;
-/**
- * @internal
- */
-export declare const CommonTableExpressionNameNode: CommonTableExpressionNameNodeFactory;
-export {};

package/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -1,19 +0,0 @@
-import type { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
-import type { OperationNode } from './operation-node.js';
-type CommonTableExpressionNodeProps = Pick<CommonTableExpressionNode, 'materialized'>;
-export interface CommonTableExpressionNode extends OperationNode {
-    readonly kind: 'CommonTableExpressionNode';
-    readonly name: CommonTableExpressionNameNode;
-    readonly materialized?: boolean;
-    readonly expression: OperationNode;
-}
-type CommonTableExpressionNodeFactory = Readonly<{
-    is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: CommonTableExpressionNameNode, expression: OperationNode): Readonly<CommonTableExpressionNode>;
-    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): Readonly<CommonTableExpressionNode>;
-}>;
-/**
- * @internal
- */
-export declare const CommonTableExpressionNode: CommonTableExpressionNodeFactory;
-export {};

package/dist/esm/operation-node/constraint-node.d.ts

@@ -1,5 +0,0 @@
-import type { CheckConstraintNode } from './check-constraint-node.js';
-import type { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
-import type { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
-import type { UniqueConstraintNode } from './unique-constraint-node.js';
-export type ConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;

package/dist/esm/operation-node/create-index-node.d.ts

@@ -1,29 +0,0 @@
-import { IdentifierNode } from './identifier-node.js';
-import type { OperationNode } from './operation-node.js';
-import type { RawNode } from './raw-node.js';
-import type { TableNode } from './table-node.js';
-import type { WhereNode } from './where-node.js';
-export type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
-export type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
-export interface CreateIndexNode extends OperationNode {
-    readonly kind: 'CreateIndexNode';
-    readonly name: IdentifierNode;
-    readonly table?: TableNode;
-    readonly columns?: OperationNode[];
-    readonly unique?: boolean;
-    readonly using?: RawNode;
-    readonly ifNotExists?: boolean;
-    readonly where?: WhereNode;
-    readonly nullsNotDistinct?: boolean;
-}
-type CreateIndexNodeFactory = Readonly<{
-    is(node: OperationNode): node is CreateIndexNode;
-    create(name: string): Readonly<CreateIndexNode>;
-    cloneWith(node: CreateIndexNode, props: CreateIndexNodeProps): Readonly<CreateIndexNode>;
-    cloneWithColumns(node: CreateIndexNode, columns: OperationNode[]): Readonly<CreateIndexNode>;
-}>;
-/**
- * @internal
- */
-export declare const CreateIndexNode: CreateIndexNodeFactory;
-export {};

package/dist/esm/operation-node/create-schema-node.d.ts

@@ -1,18 +0,0 @@
-import { IdentifierNode } from './identifier-node.js';
-import type { OperationNode } from './operation-node.js';
-export type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
-export interface CreateSchemaNode extends OperationNode {
-    readonly kind: 'CreateSchemaNode';
-    readonly schema: IdentifierNode;
-    readonly ifNotExists?: boolean;
-}
-type CreateSchemaNodeFactory = Readonly<{
-    is(node: OperationNode): node is CreateSchemaNode;
-    create(schema: string, params?: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
-    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): Readonly<CreateSchemaNode>;
-}>;
-/**
- * @internal
- */
-export declare const CreateSchemaNode: CreateSchemaNodeFactory;
-export {};

package/dist/esm/operation-node/create-table-node.d.ts

@@ -1,34 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import type { TableNode } from './table-node.js';
-import type { ConstraintNode } from './constraint-node.js';
-import type { ColumnDefinitionNode } from './column-definition-node.js';
-import type { ArrayItemType } from '../util/type-utils.js';
-export declare const ON_COMMIT_ACTIONS: string[];
-export type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
-export type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
-export interface CreateTableNode extends OperationNode {
-    readonly kind: 'CreateTableNode';
-    readonly table: TableNode;
-    readonly columns: ReadonlyArray<ColumnDefinitionNode>;
-    readonly constraints?: ReadonlyArray<ConstraintNode>;
-    readonly temporary?: boolean;
-    readonly ifNotExists?: boolean;
-    readonly onCommit?: OnCommitAction;
-    readonly frontModifiers?: ReadonlyArray<OperationNode>;
-    readonly endModifiers?: ReadonlyArray<OperationNode>;
-    readonly selectQuery?: OperationNode;
-}
-type CreateTableNodeFactory = Readonly<{
-    is(node: OperationNode): node is CreateTableNode;
-    create(table: TableNode): Readonly<CreateTableNode>;
-    cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): Readonly<CreateTableNode>;
-    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): Readonly<CreateTableNode>;
-    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
-    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
-    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): Readonly<CreateTableNode>;
-}>;
-/**
- * @internal
- */
-export declare const CreateTableNode: CreateTableNodeFactory;
-export {};

package/dist/esm/operation-node/create-table-node.js

@@ -1,54 +0,0 @@
-/// <reference types="./create-table-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
-export const ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
-/**
- * @internal
- */
-export const CreateTableNode = freeze({
-    is(node) {
-        return node.kind === 'CreateTableNode';
-    },
-    create(table) {
-        return freeze({
-            kind: 'CreateTableNode',
-            table,
-            columns: freeze([]),
-        });
-    },
-    cloneWithColumn(createTable, column) {
-        return freeze({
-            ...createTable,
-            columns: freeze([...createTable.columns, column]),
-        });
-    },
-    cloneWithConstraint(createTable, constraint) {
-        return freeze({
-            ...createTable,
-            constraints: createTable.constraints
-                ? freeze([...createTable.constraints, constraint])
-                : freeze([constraint]),
-        });
-    },
-    cloneWithFrontModifier(createTable, modifier) {
-        return freeze({
-            ...createTable,
-            frontModifiers: createTable.frontModifiers
-                ? freeze([...createTable.frontModifiers, modifier])
-                : freeze([modifier]),
-        });
-    },
-    cloneWithEndModifier(createTable, modifier) {
-        return freeze({
-            ...createTable,
-            endModifiers: createTable.endModifiers
-                ? freeze([...createTable.endModifiers, modifier])
-                : freeze([modifier]),
-        });
-    },
-    cloneWith(createTable, params) {
-        return freeze({
-            ...createTable,
-            ...params,
-        });
-    },
-});

package/dist/esm/operation-node/create-type-node.d.ts

@@ -1,19 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import { ValueListNode } from './value-list-node.js';
-export type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
-export interface CreateTypeNode extends OperationNode {
-    readonly kind: 'CreateTypeNode';
-    readonly name: SchemableIdentifierNode;
-    readonly enum?: ValueListNode;
-}
-type CreateTypeNodeFactory = Readonly<{
-    is(node: OperationNode): node is CreateTypeNode;
-    create(name: SchemableIdentifierNode): Readonly<CreateTypeNode>;
-    cloneWithEnum(createType: CreateTypeNode, values: readonly string[]): Readonly<CreateTypeNode>;
-}>;
-/**
- * @internal
- */
-export declare const CreateTypeNode: CreateTypeNodeFactory;
-export {};

package/dist/esm/operation-node/create-view-node.d.ts

@@ -1,26 +0,0 @@
-import type { ColumnNode } from './column-node.js';
-import type { OperationNode } from './operation-node.js';
-import type { RawNode } from './raw-node.js';
-import { SchemableIdentifierNode } from './schemable-identifier-node.js';
-import type { SelectQueryNode } from './select-query-node.js';
-export type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
-export interface CreateViewNode extends OperationNode {
-    readonly kind: 'CreateViewNode';
-    readonly name: SchemableIdentifierNode;
-    readonly temporary?: boolean;
-    readonly materialized?: boolean;
-    readonly orReplace?: boolean;
-    readonly ifNotExists?: boolean;
-    readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly as?: SelectQueryNode | RawNode;
-}
-type CreateViewNodeFactory = Readonly<{
-    is(node: OperationNode): node is CreateViewNode;
-    create(name: string): Readonly<CreateViewNode>;
-    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): Readonly<CreateViewNode>;
-}>;
-/**
- * @internal
- */
-export declare const CreateViewNode: CreateViewNodeFactory;
-export {};

package/dist/esm/operation-node/data-type-node.d.ts

@@ -1,19 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
-type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
-export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
-export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
-export interface DataTypeNode extends OperationNode {
-    readonly kind: 'DataTypeNode';
-    readonly dataType: ColumnDataType;
-}
-type DataTypeNodeFactory = Readonly<{
-    is(node: OperationNode): node is DataTypeNode;
-    create(dataType: ColumnDataType): Readonly<DataTypeNode>;
-}>;
-/**
- * @internal
- */
-export declare const DataTypeNode: DataTypeNodeFactory;
-export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
-export {};

package/dist/esm/operation-node/data-type-node.js

@@ -1,83 +0,0 @@
-/// <reference types="./data-type-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
-const SIMPLE_COLUMN_DATA_TYPES = [
-    'varchar',
-    'char',
-    'text',
-    'integer',
-    'int2',
-    'int4',
-    'int8',
-    'smallint',
-    'bigint',
-    'boolean',
-    'real',
-    'double precision',
-    'float4',
-    'float8',
-    'decimal',
-    'numeric',
-    'binary',
-    'bytea',
-    'date',
-    'datetime',
-    'time',
-    'timetz',
-    'timestamp',
-    'timestamptz',
-    'serial',
-    'bigserial',
-    'uuid',
-    'json',
-    'jsonb',
-    'blob',
-    'varbinary',
-    'int4range',
-    'int4multirange',
-    'int8range',
-    'int8multirange',
-    'numrange',
-    'nummultirange',
-    'tsrange',
-    'tsmultirange',
-    'tstzrange',
-    'tstzmultirange',
-    'daterange',
-    'datemultirange',
-];
-const COLUMN_DATA_TYPE_REGEX = [
-    /^varchar\(\d+\)$/,
-    /^char\(\d+\)$/,
-    /^decimal\(\d+, \d+\)$/,
-    /^numeric\(\d+, \d+\)$/,
-    /^binary\(\d+\)$/,
-    /^datetime\(\d+\)$/,
-    /^time\(\d+\)$/,
-    /^timetz\(\d+\)$/,
-    /^timestamp\(\d+\)$/,
-    /^timestamptz\(\d+\)$/,
-    /^varbinary\(\d+\)$/,
-];
-/**
- * @internal
- */
-export const DataTypeNode = freeze({
-    is(node) {
-        return node.kind === 'DataTypeNode';
-    },
-    create(dataType) {
-        return freeze({
-            kind: 'DataTypeNode',
-            dataType,
-        });
-    },
-});
-export function isColumnDataType(dataType) {
-    if (SIMPLE_COLUMN_DATA_TYPES.includes(dataType)) {
-        return true;
-    }
-    if (COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType))) {
-        return true;
-    }
-    return false;
-}

package/dist/esm/operation-node/default-insert-value-node.d.ts

@@ -1,13 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface DefaultInsertValueNode extends OperationNode {
-    readonly kind: 'DefaultInsertValueNode';
-}
-type DefaultInsertValueNodeFactory = Readonly<{
-    is(node: OperationNode): node is DefaultInsertValueNode;
-    create(): Readonly<DefaultInsertValueNode>;
-}>;
-/**
- * @internal
- */
-export declare const DefaultInsertValueNode: DefaultInsertValueNodeFactory;
-export {};

package/dist/esm/operation-node/default-value-node.d.ts

@@ -1,14 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface DefaultValueNode extends OperationNode {
-    readonly kind: 'DefaultValueNode';
-    readonly defaultValue: OperationNode;
-}
-type DefaultValueNodeFactory = Readonly<{
-    is(node: OperationNode): node is DefaultValueNode;
-    create(defaultValue: OperationNode): Readonly<DefaultValueNode>;
-}>;
-/**
- * @internal
- */
-export declare const DefaultValueNode: DefaultValueNodeFactory;
-export {};