@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/operation-node/having-node.js

@@ -0,0 +1,26 @@
+/// <reference types="./having-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { AndNode } from './and-node.js';
+import { OrNode } from './or-node.js';
+/**
+ * @internal
+ */
+export const HavingNode = freeze({
+    is(node) {
+        return node.kind === 'HavingNode';
+    },
+    create(filter) {
+        return freeze({
+            kind: 'HavingNode',
+            having: filter,
+        });
+    },
+    cloneWithOperation(havingNode, operator, operation) {
+        return freeze({
+            ...havingNode,
+            having: operator === 'And'
+                ? AndNode.create(havingNode.having, operation)
+                : OrNode.create(havingNode.having, operation),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/identifier-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/identifier-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/insert-query-node.d.ts

@@ -0,0 +1,42 @@
+import type { ColumnNode } from './column-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { OnConflictNode } from './on-conflict-node.js';
+import type { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OrActionNode } from './or-action-node.js';
+import type { OutputNode } from './output-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { TableNode } from './table-node.js';
+import type { TopNode } from './top-node.js';
+import type { WithNode } from './with-node.js';
+export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
+export interface InsertQueryNode extends OperationNode {
+    readonly kind: 'InsertQueryNode';
+    readonly into?: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly values?: OperationNode;
+    readonly returning?: ReturningNode;
+    readonly onConflict?: OnConflictNode;
+    readonly onDuplicateKey?: OnDuplicateKeyNode;
+    readonly with?: WithNode;
+    /** @deprecated use {@link orAction} instead. */
+    readonly ignore?: boolean;
+    readonly orAction?: OrActionNode;
+    readonly replace?: boolean;
+    readonly explain?: ExplainNode;
+    readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+}
+type InsertQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): Readonly<InsertQueryNode>;
+    createWithoutInto(): Readonly<InsertQueryNode>;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): Readonly<InsertQueryNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const InsertQueryNode: InsertQueryNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/insert-query-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./insert-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const InsertQueryNode = freeze({
+    is(node) {
+        return node.kind === 'InsertQueryNode';
+    },
+    create(into, withNode, replace) {
+        return freeze({
+            kind: 'InsertQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+            replace,
+        });
+    },
+    createWithoutInto() {
+        return freeze({
+            kind: 'InsertQueryNode',
+        });
+    },
+    cloneWith(insertQuery, props) {
+        return freeze({
+            ...insertQuery,
+            ...props,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/join-node.d.ts

@@ -0,0 +1,20 @@
+import { OnNode } from './on-node.js';
+import type { OperationNode } from './operation-node.js';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'CrossJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'LateralCrossJoin' | 'Using' | 'OuterApply' | 'CrossApply';
+export interface JoinNode extends OperationNode {
+    readonly kind: 'JoinNode';
+    readonly joinType: JoinType;
+    readonly table: OperationNode;
+    readonly on?: OnNode;
+}
+type JoinNodeFactory = Readonly<{
+    is(node: OperationNode): node is JoinNode;
+    create(joinType: JoinType, table: OperationNode): Readonly<JoinNode>;
+    createWithOn(joinType: JoinType, table: OperationNode, on: OperationNode): Readonly<JoinNode>;
+    cloneWithOn(joinNode: JoinNode, operation: OperationNode): Readonly<JoinNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const JoinNode: JoinNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/join-node.js

@@ -0,0 +1,35 @@
+/// <reference types="./join-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { OnNode } from './on-node.js';
+/**
+ * @internal
+ */
+export const JoinNode = freeze({
+    is(node) {
+        return node.kind === 'JoinNode';
+    },
+    create(joinType, table) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: undefined,
+        });
+    },
+    createWithOn(joinType, table, on) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on: OnNode.create(on),
+        });
+    },
+    cloneWithOn(joinNode, operation) {
+        return freeze({
+            ...joinNode,
+            on: joinNode.on
+                ? OnNode.cloneWithOperation(joinNode.on, 'And', operation)
+                : OnNode.create(operation),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-operator-chain-node.d.ts

@@ -0,0 +1,18 @@
+import type { OperationNode } from './operation-node.js';
+import type { OperatorNode } from './operator-node.js';
+import type { ValueNode } from './value-node.js';
+export interface JSONOperatorChainNode extends OperationNode {
+    readonly kind: 'JSONOperatorChainNode';
+    readonly operator: OperatorNode;
+    readonly values: readonly ValueNode[];
+}
+type JSONOperatorChainNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONOperatorChainNode;
+    create(operator: OperatorNode): Readonly<JSONOperatorChainNode>;
+    cloneWithValue(node: JSONOperatorChainNode, value: ValueNode): Readonly<JSONOperatorChainNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const JSONOperatorChainNode: JSONOperatorChainNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-operator-chain-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-operator-chain-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONOperatorChainNode = freeze({
+    is(node) {
+        return node.kind === 'JSONOperatorChainNode';
+    },
+    create(operator) {
+        return freeze({
+            kind: 'JSONOperatorChainNode',
+            operator,
+            values: freeze([]),
+        });
+    },
+    cloneWithValue(node, value) {
+        return freeze({
+            ...node,
+            values: freeze([...node.values, value]),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-path-leg-node.d.ts

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+export type JSONPathLegType = 'Member' | 'ArrayLocation';
+export interface JSONPathLegNode extends OperationNode {
+    readonly kind: 'JSONPathLegNode';
+    readonly type: JSONPathLegType;
+    readonly value: string | number;
+}
+type JSONPathLegNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONPathLegNode;
+    create(type: JSONPathLegType, value: string | number): Readonly<JSONPathLegNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const JSONPathLegNode: JSONPathLegNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-path-leg-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-path-node.d.ts

@@ -0,0 +1,18 @@
+import type { JSONPathLegNode } from './json-path-leg-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OperatorNode } from './operator-node.js';
+export interface JSONPathNode extends OperationNode {
+    readonly kind: 'JSONPathNode';
+    readonly inOperator?: OperatorNode;
+    readonly pathLegs: ReadonlyArray<JSONPathLegNode>;
+}
+type JSONPathNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONPathNode;
+    create(inOperator?: OperatorNode): Readonly<JSONPathNode>;
+    cloneWithLeg(jsonPathNode: JSONPathNode, pathLeg: JSONPathLegNode): Readonly<JSONPathNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const JSONPathNode: JSONPathNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-path-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./json-path-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const JSONPathNode = freeze({
+    is(node) {
+        return node.kind === 'JSONPathNode';
+    },
+    create(inOperator) {
+        return freeze({
+            kind: 'JSONPathNode',
+            inOperator,
+            pathLegs: freeze([]),
+        });
+    },
+    cloneWithLeg(jsonPathNode, pathLeg) {
+        return freeze({
+            ...jsonPathNode,
+            pathLegs: freeze([...jsonPathNode.pathLegs, pathLeg]),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-reference-node.d.ts

@@ -0,0 +1,19 @@
+import type { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import type { JSONPathNode } from './json-path-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferenceNode } from './reference-node.js';
+export interface JSONReferenceNode extends OperationNode {
+    readonly kind: 'JSONReferenceNode';
+    readonly reference: ReferenceNode;
+    readonly traversal: JSONPathNode | JSONOperatorChainNode;
+}
+type JSONReferenceNodeFactory = Readonly<{
+    is(node: OperationNode): node is JSONReferenceNode;
+    create(reference: ReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): Readonly<JSONReferenceNode>;
+    cloneWithTraversal(node: JSONReferenceNode, traversal: JSONPathNode | JSONOperatorChainNode): Readonly<JSONReferenceNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const JSONReferenceNode: JSONReferenceNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/json-reference-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/limit-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/limit-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/list-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/list-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/matched-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/matched-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/merge-query-node.d.ts

@@ -0,0 +1,32 @@
+import type { AliasNode } from './alias-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OutputNode } from './output-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { TableNode } from './table-node.js';
+import type { TopNode } from './top-node.js';
+import { WhenNode } from './when-node.js';
+import type { WithNode } from './with-node.js';
+export interface MergeQueryNode extends OperationNode {
+    readonly kind: 'MergeQueryNode';
+    readonly into: TableNode | AliasNode;
+    readonly using?: JoinNode;
+    readonly whens?: ReadonlyArray<WhenNode>;
+    readonly with?: WithNode;
+    readonly top?: TopNode;
+    readonly returning?: ReturningNode;
+    readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+}
+type MergeQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is MergeQueryNode;
+    create(into: TableNode | AliasNode, withNode?: WithNode): Readonly<MergeQueryNode>;
+    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): Readonly<MergeQueryNode>;
+    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): Readonly<MergeQueryNode>;
+    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): Readonly<MergeQueryNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const MergeQueryNode: MergeQueryNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/esm/operation-node/merge-query-node.js

@@ -0,0 +1,43 @@
+/// <reference types="./merge-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const MergeQueryNode = freeze({
+    is(node) {
+        return node.kind === 'MergeQueryNode';
+    },
+    create(into, withNode) {
+        return freeze({
+            kind: 'MergeQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithUsing(mergeNode, using) {
+        return freeze({
+            ...mergeNode,
+            using,
+        });
+    },
+    cloneWithWhen(mergeNode, when) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([...mergeNode.whens, when])
+                : freeze([when]),
+        });
+    },
+    cloneWithThen(mergeNode, then) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([
+                    ...mergeNode.whens.slice(0, -1),
+                    WhenNode.cloneWithResult(mergeNode.whens[mergeNode.whens.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/esm/operation-node/modify-column-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/modify-column-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/offset-node.d.ts

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/offset-node.js

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

package/dist/server/node_modules/kysely/dist/esm/operation-node/on-conflict-node.d.ts

@@ -0,0 +1,32 @@
+import type { ColumnNode } from './column-node.js';
+import type { ColumnUpdateNode } from './column-update-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import { WhereNode } from './where-node.js';
+export type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
+export interface OnConflictNode extends OperationNode {
+    readonly kind: 'OnConflictNode';
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly constraint?: IdentifierNode;
+    readonly indexExpression?: OperationNode;
+    readonly indexWhere?: WhereNode;
+    readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly updateWhere?: WhereNode;
+    readonly doNothing?: boolean;
+}
+type OnConflictNodeFactory = Readonly<{
+    is(node: OperationNode): node is OnConflictNode;
+    create(): Readonly<OnConflictNode>;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): Readonly<OnConflictNode>;
+    cloneWithIndexWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithIndexOrWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithUpdateWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithUpdateOrWhere(node: OnConflictNode, operation: OperationNode): Readonly<OnConflictNode>;
+    cloneWithoutIndexWhere(node: OnConflictNode): Readonly<OnConflictNode>;
+    cloneWithoutUpdateWhere(node: OnConflictNode): Readonly<OnConflictNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const OnConflictNode: OnConflictNodeFactory;
+export {};