noormme 1.0.0

package/dist/esm/operation-node/aggregate-function-node.js

@@ -0,0 +1,56 @@
+/// <reference types="./aggregate-function-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+/**
+ * @internal
+ */
+export const AggregateFunctionNode = freeze({
+    is(node) {
+        return node.kind === 'AggregateFunctionNode';
+    },
+    create(aggregateFunction, aggregated = []) {
+        return freeze({
+            kind: 'AggregateFunctionNode',
+            func: aggregateFunction,
+            aggregated,
+        });
+    },
+    cloneWithDistinct(aggregateFunctionNode) {
+        return freeze({
+            ...aggregateFunctionNode,
+            distinct: true,
+        });
+    },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
+        const prop = withinGroup ? 'withinGroup' : 'orderBy';
+        return freeze({
+            ...aggregateFunctionNode,
+            [prop]: aggregateFunctionNode[prop]
+                ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems)
+                : OrderByNode.create(orderItems),
+        });
+    },
+    cloneWithFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOrFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOver(aggregateFunctionNode, over) {
+        return freeze({
+            ...aggregateFunctionNode,
+            over,
+        });
+    },
+});

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

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

package/dist/esm/operation-node/alias-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./alias-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AliasNode = freeze({
+    is(node) {
+        return node.kind === 'AliasNode';
+    },
+    create(node, alias) {
+        return freeze({
+            kind: 'AliasNode',
+            node,
+            alias,
+        });
+    },
+});

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

@@ -0,0 +1,21 @@
+import { OperationNode } from './operation-node.js';
+import { ColumnNode } from './column-node.js';
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const AlterColumnNode: Readonly<{
+    is(node: OperationNode): node is AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
+}>;

package/dist/esm/operation-node/alter-column-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./alter-column-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const AlterColumnNode = freeze({
+    is(node) {
+        return node.kind === 'AlterColumnNode';
+    },
+    create(column, prop, value) {
+        return freeze({
+            kind: 'AlterColumnNode',
+            column: ColumnNode.create(column),
+            [prop]: value,
+        });
+    },
+});

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

@@ -0,0 +1,36 @@
+import { OperationNode } from './operation-node.js';
+import { AddColumnNode } from './add-column-node.js';
+import { DropColumnNode } from './drop-column-node.js';
+import { TableNode } from './table-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import { RenameColumnNode } from './rename-column-node.js';
+import { AlterColumnNode } from './alter-column-node.js';
+import { AddConstraintNode } from './add-constraint-node.js';
+import { DropConstraintNode } from './drop-constraint-node.js';
+import { ModifyColumnNode } from './modify-column-node.js';
+import { DropIndexNode } from './drop-index-node.js';
+import { AddIndexNode } from './add-index-node.js';
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const AlterTableNode: Readonly<{
+    is(node: OperationNode): node is AlterTableNode;
+    create(table: TableNode): AlterTableNode;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
+}>;

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

@@ -0,0 +1,30 @@
+/// <reference types="./alter-table-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AlterTableNode = freeze({
+    is(node) {
+        return node.kind === 'AlterTableNode';
+    },
+    create(table) {
+        return freeze({
+            kind: 'AlterTableNode',
+            table,
+        });
+    },
+    cloneWithTableProps(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumnAlteration(node, columnAlteration) {
+        return freeze({
+            ...node,
+            columnAlterations: node.columnAlterations
+                ? [...node.columnAlterations, columnAlteration]
+                : [columnAlteration],
+        });
+    },
+});

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

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

package/dist/esm/operation-node/and-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./and-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AndNode = freeze({
+    is(node) {
+        return node.kind === 'AndNode';
+    },
+    create(left, right) {
+        return freeze({
+            kind: 'AndNode',
+            left,
+            right,
+        });
+    },
+});

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

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

package/dist/esm/operation-node/binary-operation-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./binary-operation-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const BinaryOperationNode = freeze({
+    is(node) {
+        return node.kind === 'BinaryOperationNode';
+    },
+    create(leftOperand, operator, rightOperand) {
+        return freeze({
+            kind: 'BinaryOperationNode',
+            leftOperand,
+            operator,
+            rightOperand,
+        });
+    },
+});

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

@@ -0,0 +1,19 @@
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const CaseNode: Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): CaseNode;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): CaseNode;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): CaseNode;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, "else" | "isStatement">>): CaseNode;
+}>;

package/dist/esm/operation-node/case-node.js

@@ -0,0 +1,40 @@
+/// <reference types="./case-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const CaseNode = freeze({
+    is(node) {
+        return node.kind === 'CaseNode';
+    },
+    create(value) {
+        return freeze({
+            kind: 'CaseNode',
+            value,
+        });
+    },
+    cloneWithWhen(caseNode, when) {
+        return freeze({
+            ...caseNode,
+            when: freeze(caseNode.when ? [...caseNode.when, when] : [when]),
+        });
+    },
+    cloneWithThen(caseNode, then) {
+        return freeze({
+            ...caseNode,
+            when: caseNode.when
+                ? freeze([
+                    ...caseNode.when.slice(0, -1),
+                    WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+    cloneWith(caseNode, props) {
+        return freeze({
+            ...caseNode,
+            ...props,
+        });
+    },
+});

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

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

package/dist/esm/operation-node/cast-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./cast-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const CastNode = freeze({
+    is(node) {
+        return node.kind === 'CastNode';
+    },
+    create(expression, dataType) {
+        return freeze({
+            kind: 'CastNode',
+            expression,
+            dataType,
+        });
+    },
+});

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

@@ -0,0 +1,14 @@
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const CheckConstraintNode: Readonly<{
+    is(node: OperationNode): node is CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): CheckConstraintNode;
+}>;

package/dist/esm/operation-node/check-constraint-node.js

@@ -0,0 +1,18 @@
+/// <reference types="./check-constraint-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CheckConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'CheckConstraintNode';
+    },
+    create(expression, constraintName) {
+        return freeze({
+            kind: 'CheckConstraintNode',
+            expression,
+            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+        });
+    },
+});

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

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

package/dist/esm/operation-node/collate-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./collate-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const CollateNode = {
+    is(node) {
+        return node.kind === 'CollateNode';
+    },
+    create(collation) {
+        return freeze({
+            kind: 'CollateNode',
+            collation: IdentifierNode.create(collation),
+        });
+    },
+};

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

@@ -0,0 +1,36 @@
+import { CheckConstraintNode } from './check-constraint-node.js';
+import { ColumnNode } from './column-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { GeneratedNode } from './generated-node.js';
+import { OperationNode } from './operation-node.js';
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const ColumnDefinitionNode: Readonly<{
+    is(node: OperationNode): node is ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): ColumnDefinitionNode;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
+    cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): ColumnDefinitionNode;
+}>;

package/dist/esm/operation-node/column-definition-node.js

@@ -0,0 +1,40 @@
+/// <reference types="./column-definition-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const ColumnDefinitionNode = freeze({
+    is(node) {
+        return node.kind === 'ColumnDefinitionNode';
+    },
+    create(column, dataType) {
+        return freeze({
+            kind: 'ColumnDefinitionNode',
+            column: ColumnNode.create(column),
+            dataType,
+        });
+    },
+    cloneWithFrontModifier(node, modifier) {
+        return freeze({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? freeze([...node.frontModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

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

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

package/dist/esm/operation-node/column-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./column-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const ColumnNode = freeze({
+    is(node) {
+        return node.kind === 'ColumnNode';
+    },
+    create(column) {
+        return freeze({
+            kind: 'ColumnNode',
+            column: IdentifierNode.create(column),
+        });
+    },
+});

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

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

package/dist/esm/operation-node/column-update-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./column-update-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const ColumnUpdateNode = freeze({
+    is(node) {
+        return node.kind === 'ColumnUpdateNode';
+    },
+    create(column, value) {
+        return freeze({
+            kind: 'ColumnUpdateNode',
+            column,
+            value,
+        });
+    },
+});

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

@@ -0,0 +1,15 @@
+import { ColumnNode } from './column-node.js';
+import { 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>;
+}
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNameNode: Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: ReadonlyArray<string>): CommonTableExpressionNameNode;
+}>;

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

@@ -0,0 +1,21 @@
+/// <reference types="./common-table-expression-name-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+import { TableNode } from './table-node.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNameNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNameNode';
+    },
+    create(tableName, columnNames) {
+        return freeze({
+            kind: 'CommonTableExpressionNameNode',
+            table: TableNode.create(tableName),
+            columns: columnNames
+                ? freeze(columnNames.map(ColumnNode.create))
+                : undefined,
+        });
+    },
+});

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

@@ -0,0 +1,18 @@
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
+import { 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;
+}
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNode: Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: OperationNode): CommonTableExpressionNode;
+    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): CommonTableExpressionNode;
+}>;
+export {};

package/dist/esm/operation-node/common-table-expression-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./common-table-expression-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNode';
+    },
+    create(name, expression) {
+        return freeze({
+            kind: 'CommonTableExpressionNode',
+            name,
+            expression,
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

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

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