@pleaseai/agent 0.1.16 → 0.1.18

package/.output/server/node_modules/kysely/dist/esm/parser/binary-operation-parser.js

@@ -0,0 +1,68 @@
+/// <reference types="./binary-operation-parser.d.ts" />
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { isBoolean, isNull, isString, isUndefined, } from '../util/object-utils.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+import { parseValueExpression, parseValueExpressionOrList, } from './value-parser.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { AndNode } from '../operation-node/and-node.js';
+import { ParensNode } from '../operation-node/parens-node.js';
+import { OrNode } from '../operation-node/or-node.js';
+export function parseValueBinaryOperationOrExpression(args) {
+    if (args.length === 3) {
+        return parseValueBinaryOperation(args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        return parseValueExpression(args[0]);
+    }
+    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
+}
+export function parseValueBinaryOperation(left, operator, right) {
+    if (isIsOperator(operator) && needsIsOperator(right)) {
+        return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), ValueNode.createImmediate(right));
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseValueExpressionOrList(right));
+}
+export function parseReferentialBinaryOperation(left, operator, right) {
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseReferenceExpression(right));
+}
+export function parseFilterObject(obj, combinator) {
+    return parseFilterList(Object.entries(obj)
+        .filter(([, v]) => !isUndefined(v))
+        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
+}
+export function parseFilterList(list, combinator, withParens = true) {
+    const combine = combinator === 'and' ? AndNode.create : OrNode.create;
+    if (list.length === 0) {
+        return BinaryOperationNode.create(ValueNode.createImmediate(1), OperatorNode.create('='), ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
+    }
+    let node = toOperationNode(list[0]);
+    for (let i = 1; i < list.length; ++i) {
+        node = combine(node, toOperationNode(list[i]));
+    }
+    if (list.length > 1 && withParens) {
+        return ParensNode.create(node);
+    }
+    return node;
+}
+function isIsOperator(operator) {
+    return operator === 'is' || operator === 'is not';
+}
+function needsIsOperator(value) {
+    return isNull(value) || isBoolean(value);
+}
+function parseOperator(operator) {
+    if (isString(operator) && OPERATORS.includes(operator)) {
+        return OperatorNode.create(operator);
+    }
+    if (isOperationNodeSource(operator)) {
+        return operator.toOperationNode();
+    }
+    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
+}
+function toOperationNode(nodeOrSource) {
+    return isOperationNodeSource(nodeOrSource)
+        ? nodeOrSource.toOperationNode()
+        : nodeOrSource;
+}

package/.output/server/node_modules/kysely/dist/esm/parser/data-type-parser.js

@@ -0,0 +1,12 @@
+/// <reference types="./data-type-parser.d.ts" />
+import { DataTypeNode, isColumnDataType, } from '../operation-node/data-type-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+export function parseDataTypeExpression(dataType) {
+    if (isOperationNodeSource(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if (isColumnDataType(dataType)) {
+        return DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/default-value-parser.js

@@ -0,0 +1,8 @@
+/// <reference types="./default-value-parser.d.ts" />
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function parseDefaultValueExpression(value) {
+    return isOperationNodeSource(value)
+        ? value.toOperationNode()
+        : ValueNode.createImmediate(value);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/expression-parser.js

@@ -0,0 +1,26 @@
+/// <reference types="./expression-parser.d.ts" />
+import { isAliasedExpression, isExpression, } from '../expression/expression.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
+export function parseExpression(exp) {
+    if (isOperationNodeSource(exp)) {
+        return exp.toOperationNode();
+    }
+    else if (isFunction(exp)) {
+        return exp(expressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
+}
+export function parseAliasedExpression(exp) {
+    if (isOperationNodeSource(exp)) {
+        return exp.toOperationNode();
+    }
+    else if (isFunction(exp)) {
+        return exp(expressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
+}
+export function isExpressionOrFactory(obj) {
+    return isExpression(obj) || isAliasedExpression(obj) || isFunction(obj);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/fetch-parser.js

@@ -0,0 +1,15 @@
+/// <reference types="./fetch-parser.d.ts" />
+import { FetchNode } from '../operation-node/fetch-node.js';
+import { isBigInt, isNumber } from '../util/object-utils.js';
+export function parseFetch(rowCount, modifier) {
+    if (!isNumber(rowCount) && !isBigInt(rowCount)) {
+        throw new Error(`Invalid fetch row count: ${rowCount}`);
+    }
+    if (!isFetchModifier(modifier)) {
+        throw new Error(`Invalid fetch modifier: ${modifier}`);
+    }
+    return FetchNode.create(rowCount, modifier);
+}
+function isFetchModifier(value) {
+    return value === 'only' || value === 'with ties';
+}

package/.output/server/node_modules/kysely/dist/esm/parser/group-by-parser.js

@@ -0,0 +1,9 @@
+/// <reference types="./group-by-parser.d.ts" />
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parseGroupBy(groupBy) {
+    groupBy = isFunction(groupBy) ? groupBy(expressionBuilder()) : groupBy;
+    return parseReferenceExpressionOrList(groupBy).map(GroupByItemNode.create);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/identifier-parser.js

@@ -0,0 +1,20 @@
+/// <reference types="./identifier-parser.d.ts" />
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export function parseSchemableIdentifier(id) {
+    const SCHEMA_SEPARATOR = '.';
+    if (id.includes(SCHEMA_SEPARATOR)) {
+        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
+        if (parts.length === 2) {
+            return SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid schemable identifier ${id}`);
+        }
+    }
+    else {
+        return SchemableIdentifierNode.create(id);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

package/.output/server/node_modules/kysely/dist/esm/parser/insert-values-parser.js

@@ -0,0 +1,62 @@
+/// <reference types="./insert-values-parser.d.ts" />
+import { ColumnNode } from '../operation-node/column-node.js';
+import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
+import { ValueListNode } from '../operation-node/value-list-node.js';
+import { freeze, isFunction, isReadonlyArray, isUndefined, } from '../util/object-utils.js';
+import { parseValueExpression } from './value-parser.js';
+import { ValuesNode } from '../operation-node/values-node.js';
+import { isExpressionOrFactory } from './expression-parser.js';
+import { DefaultInsertValueNode } from '../operation-node/default-insert-value-node.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+export function parseInsertExpression(arg) {
+    const objectOrList = isFunction(arg) ? arg(expressionBuilder()) : arg;
+    const list = isReadonlyArray(objectOrList)
+        ? objectOrList
+        : freeze([objectOrList]);
+    return parseInsertColumnsAndValues(list);
+}
+function parseInsertColumnsAndValues(rows) {
+    const columns = parseColumnNamesAndIndexes(rows);
+    return [
+        freeze([...columns.keys()].map(ColumnNode.create)),
+        ValuesNode.create(rows.map((row) => parseRowValues(row, columns))),
+    ];
+}
+function parseColumnNamesAndIndexes(rows) {
+    const columns = new Map();
+    for (const row of rows) {
+        const cols = Object.keys(row);
+        for (const col of cols) {
+            if (!columns.has(col) && row[col] !== undefined) {
+                columns.set(col, columns.size);
+            }
+        }
+    }
+    return columns;
+}
+function parseRowValues(row, columns) {
+    const rowColumns = Object.keys(row);
+    const rowValues = Array.from({
+        length: columns.size,
+    });
+    let hasUndefinedOrComplexColumns = false;
+    let indexedRowColumns = rowColumns.length;
+    for (const col of rowColumns) {
+        const columnIdx = columns.get(col);
+        if (isUndefined(columnIdx)) {
+            indexedRowColumns--;
+            continue;
+        }
+        const value = row[col];
+        if (isUndefined(value) || isExpressionOrFactory(value)) {
+            hasUndefinedOrComplexColumns = true;
+        }
+        rowValues[columnIdx] = value;
+    }
+    const hasMissingColumns = indexedRowColumns < columns.size;
+    if (hasMissingColumns || hasUndefinedOrComplexColumns) {
+        const defaultValue = DefaultInsertValueNode.create();
+        return ValueListNode.create(rowValues.map((it) => isUndefined(it) ? defaultValue : parseValueExpression(it)));
+    }
+    return PrimitiveValueListNode.create(rowValues);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/join-parser.js

@@ -0,0 +1,28 @@
+/// <reference types="./join-parser.d.ts" />
+import { JoinNode } from '../operation-node/join-node.js';
+import { parseReferentialBinaryOperation } from './binary-operation-parser.js';
+import { createJoinBuilder } from './parse-utils.js';
+import { parseTableExpression, } from './table-parser.js';
+export function parseJoin(joinType, args) {
+    if (args.length === 3) {
+        return parseSingleOnJoin(joinType, args[0], args[1], args[2]);
+    }
+    else if (args.length === 2) {
+        return parseCallbackJoin(joinType, args[0], args[1]);
+    }
+    else if (args.length === 1) {
+        return parseOnlessJoin(joinType, args[0]);
+    }
+    else {
+        throw new Error('not implemented');
+    }
+}
+function parseCallbackJoin(joinType, from, callback) {
+    return callback(createJoinBuilder(joinType, from)).toOperationNode();
+}
+function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
+    return JoinNode.createWithOn(joinType, parseTableExpression(from), parseReferentialBinaryOperation(lhsColumn, '=', rhsColumn));
+}
+function parseOnlessJoin(joinType, from) {
+    return JoinNode.create(joinType, parseTableExpression(from));
+}

package/.output/server/node_modules/kysely/dist/esm/parser/merge-parser.js

@@ -0,0 +1,28 @@
+/// <reference types="./merge-parser.d.ts" />
+import { MatchedNode } from '../operation-node/matched-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+import { isString } from '../util/object-utils.js';
+import { parseFilterList, parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from './binary-operation-parser.js';
+export function parseMergeWhen(type, args, refRight) {
+    return WhenNode.create(parseFilterList([
+        MatchedNode.create(!type.isMatched, type.bySource),
+        ...(args && args.length > 0
+            ? [
+                args.length === 3 && refRight
+                    ? parseReferentialBinaryOperation(args[0], args[1], args[2])
+                    : parseValueBinaryOperationOrExpression(args),
+            ]
+            : []),
+    ], 'and', false));
+}
+export function parseMergeThen(result) {
+    if (isString(result)) {
+        return RawNode.create([result], []);
+    }
+    if (isOperationNodeSource(result)) {
+        return result.toOperationNode();
+    }
+    return result;
+}

package/.output/server/node_modules/kysely/dist/esm/parser/on-commit-action-parse.js

@@ -0,0 +1,8 @@
+/// <reference types="./on-commit-action-parse.d.ts" />
+import { ON_COMMIT_ACTIONS, } from '../operation-node/create-table-node.js';
+export function parseOnCommitAction(action) {
+    if (ON_COMMIT_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnCommitAction ${action}`);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/on-modify-action-parser.js

@@ -0,0 +1,8 @@
+/// <reference types="./on-modify-action-parser.d.ts" />
+import { ON_MODIFY_FOREIGN_ACTIONS, } from '../operation-node/references-node.js';
+export function parseOnModifyForeignAction(action) {
+    if (ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnModifyForeignAction ${action}`);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/order-by-parser.js

@@ -0,0 +1,67 @@
+/// <reference types="./order-by-parser.d.ts" />
+import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { isExpression } from '../expression/expression.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { OrderByItemBuilder } from '../query-builder/order-by-item-builder.js';
+import { logOnce } from '../util/log-once.js';
+import { isExpressionOrFactory, parseExpression, } from './expression-parser.js';
+import { parseStringReference, } from './reference-parser.js';
+export function isOrderByDirection(thing) {
+    return thing === 'asc' || thing === 'desc';
+}
+export function parseOrderBy(args) {
+    if (args.length === 2) {
+        return [parseOrderByItem(args[0], args[1])];
+    }
+    if (args.length === 1) {
+        const [orderBy] = args;
+        if (Array.isArray(orderBy)) {
+            logOnce('orderBy(array) is deprecated, use multiple orderBy calls instead.');
+            return orderBy.map((item) => parseOrderByItem(item));
+        }
+        return [parseOrderByItem(orderBy)];
+    }
+    throw new Error(`Invalid number of arguments at order by! expected 1-2, received ${args.length}`);
+}
+export function parseOrderByItem(expr, modifiers) {
+    const parsedRef = parseOrderByExpression(expr);
+    if (OrderByItemNode.is(parsedRef)) {
+        if (modifiers) {
+            throw new Error('Cannot specify direction twice!');
+        }
+        return parsedRef;
+    }
+    return parseOrderByWithModifiers(parsedRef, modifiers);
+}
+function parseOrderByExpression(expr) {
+    if (isExpressionOrFactory(expr)) {
+        return parseExpression(expr);
+    }
+    if (isDynamicReferenceBuilder(expr)) {
+        return expr.toOperationNode();
+    }
+    const [ref, direction] = expr.split(' ');
+    if (direction) {
+        logOnce("`orderBy('column asc')` is deprecated. Use `orderBy('column', 'asc')` instead.");
+        return parseOrderByWithModifiers(parseStringReference(ref), direction);
+    }
+    return parseStringReference(expr);
+}
+function parseOrderByWithModifiers(expr, modifiers) {
+    if (typeof modifiers === 'string') {
+        if (!isOrderByDirection(modifiers)) {
+            throw new Error(`Invalid order by direction: ${modifiers}`);
+        }
+        return OrderByItemNode.create(expr, RawNode.createWithSql(modifiers));
+    }
+    if (isExpression(modifiers)) {
+        logOnce("`orderBy(..., expr)` is deprecated. Use `orderBy(..., 'asc')` or `orderBy(..., (ob) => ...)` instead.");
+        return OrderByItemNode.create(expr, modifiers.toOperationNode());
+    }
+    const node = OrderByItemNode.create(expr);
+    if (!modifiers) {
+        return node;
+    }
+    return modifiers(new OrderByItemBuilder({ node })).toOperationNode();
+}

package/.output/server/node_modules/kysely/dist/esm/parser/parse-utils.js

@@ -0,0 +1,33 @@
+/// <reference types="./parse-utils.d.ts" />
+import { JoinNode } from '../operation-node/join-node.js';
+import { OverNode } from '../operation-node/over-node.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
+import { createSelectQueryBuilder as newSelectQueryBuilder, } from '../query-builder/select-query-builder.js';
+import { QueryCreator } from '../query-creator.js';
+import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { createQueryId } from '../util/query-id.js';
+import { parseTableExpression, parseTableExpressionOrList, } from './table-parser.js';
+export function createSelectQueryBuilder() {
+    return newSelectQueryBuilder({
+        queryId: createQueryId(),
+        executor: NOOP_QUERY_EXECUTOR,
+        queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList([])),
+    });
+}
+export function createQueryCreator() {
+    return new QueryCreator({
+        executor: NOOP_QUERY_EXECUTOR,
+    });
+}
+export function createJoinBuilder(joinType, table) {
+    return new JoinBuilder({
+        joinNode: JoinNode.create(joinType, parseTableExpression(table)),
+    });
+}
+export function createOverBuilder() {
+    return new OverBuilder({
+        overNode: OverNode.create(),
+    });
+}

package/.output/server/node_modules/kysely/dist/esm/parser/partition-by-parser.js

@@ -0,0 +1,6 @@
+/// <reference types="./partition-by-parser.d.ts" />
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parsePartitionBy(partitionBy) {
+    return parseReferenceExpressionOrList(partitionBy).map(PartitionByItemNode.create);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/reference-parser.js

@@ -0,0 +1,95 @@
+/// <reference types="./reference-parser.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
+import { OperatorNode, isJSONOperator, } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
+export function parseSimpleReferenceExpression(exp) {
+    if (isString(exp)) {
+        return parseStringReference(exp);
+    }
+    return exp.toOperationNode();
+}
+export function parseReferenceExpressionOrList(arg) {
+    if (isReadonlyArray(arg)) {
+        return arg.map((it) => parseReferenceExpression(it));
+    }
+    else {
+        return [parseReferenceExpression(arg)];
+    }
+}
+export function parseReferenceExpression(exp) {
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
+    }
+    return parseSimpleReferenceExpression(exp);
+}
+export function parseJSONReference(ref, op) {
+    const referenceNode = parseStringReference(ref);
+    if (isJSONOperator(op)) {
+        return JSONReferenceNode.create(referenceNode, JSONOperatorChainNode.create(OperatorNode.create(op)));
+    }
+    const opWithoutLastChar = op.slice(0, -1);
+    if (isJSONOperator(opWithoutLastChar)) {
+        return JSONReferenceNode.create(referenceNode, JSONPathNode.create(OperatorNode.create(opWithoutLastChar)));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
+export function parseStringReference(ref) {
+    const COLUMN_SEPARATOR = '.';
+    if (!ref.includes(COLUMN_SEPARATOR)) {
+        return ReferenceNode.create(ColumnNode.create(ref));
+    }
+    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
+    if (parts.length === 3) {
+        return parseStringReferenceWithTableAndSchema(parts);
+    }
+    if (parts.length === 2) {
+        return parseStringReferenceWithTable(parts);
+    }
+    throw new Error(`invalid column reference ${ref}`);
+}
+export function parseAliasedStringReference(ref) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (ref.includes(ALIAS_SEPARATOR)) {
+        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
+    }
+    else {
+        return parseStringReference(ref);
+    }
+}
+export function parseColumnName(column) {
+    return ColumnNode.create(column);
+}
+export function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!isOrderByDirection(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return parseOrderBy([columnName, order])[0];
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
+function parseStringReferenceWithTableAndSchema(parts) {
+    const [schema, table, column] = parts;
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
+}
+function parseStringReferenceWithTable(parts) {
+    const [table, column] = parts;
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
+}
+function trim(str) {
+    return str.trim();
+}

package/.output/server/node_modules/kysely/dist/esm/parser/savepoint-parser.js

@@ -0,0 +1,9 @@
+/// <reference types="./savepoint-parser.d.ts" />
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+export function parseSavepointCommand(command, savepointName) {
+    return RawNode.createWithChildren([
+        RawNode.createWithSql(`${command} `),
+        IdentifierNode.create(savepointName), // ensures savepointName gets sanitized
+    ]);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/select-parser.js

@@ -0,0 +1,47 @@
+/// <reference types="./select-parser.d.ts" />
+import { isFunction, isReadonlyArray, isString } from '../util/object-utils.js';
+import { SelectionNode } from '../operation-node/selection-node.js';
+import { parseAliasedStringReference } from './reference-parser.js';
+import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { parseAliasedExpression, } from './expression-parser.js';
+import { parseTable } from './table-parser.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+export function parseSelectArg(selection) {
+    if (isFunction(selection)) {
+        return parseSelectArg(selection(expressionBuilder()));
+    }
+    else if (isReadonlyArray(selection)) {
+        return selection.map((it) => parseSelectExpression(it));
+    }
+    else {
+        return [parseSelectExpression(selection)];
+    }
+}
+function parseSelectExpression(selection) {
+    if (isString(selection)) {
+        return SelectionNode.create(parseAliasedStringReference(selection));
+    }
+    else if (isDynamicReferenceBuilder(selection)) {
+        return SelectionNode.create(selection.toOperationNode());
+    }
+    else {
+        return SelectionNode.create(parseAliasedExpression(selection));
+    }
+}
+export function parseSelectAll(table) {
+    if (!table) {
+        return [SelectionNode.createSelectAll()];
+    }
+    else if (Array.isArray(table)) {
+        return table.map(parseSelectAllArg);
+    }
+    else {
+        return [parseSelectAllArg(table)];
+    }
+}
+function parseSelectAllArg(table) {
+    if (isString(table)) {
+        return SelectionNode.createSelectAllFromTable(parseTable(table));
+    }
+    throw new Error(`invalid value selectAll expression: ${JSON.stringify(table)}`);
+}

package/.output/server/node_modules/kysely/dist/esm/parser/set-operation-parser.js

@@ -0,0 +1,14 @@
+/// <reference types="./set-operation-parser.d.ts" />
+import { createExpressionBuilder, } from '../expression/expression-builder.js';
+import { SetOperationNode, } from '../operation-node/set-operation-node.js';
+import { isFunction, isReadonlyArray } from '../util/object-utils.js';
+import { parseExpression } from './expression-parser.js';
+export function parseSetOperations(operator, expression, all) {
+    if (isFunction(expression)) {
+        expression = expression(createExpressionBuilder());
+    }
+    if (!isReadonlyArray(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => SetOperationNode.create(operator, parseExpression(expr), all));
+}

package/.output/server/node_modules/kysely/dist/esm/parser/table-parser.js

@@ -0,0 +1,49 @@
+/// <reference types="./table-parser.d.ts" />
+import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { parseAliasedExpression, } from './expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isAliasedDynamicTableBuilder, } from '../dynamic/dynamic-table-builder.js';
+export function parseTableExpressionOrList(table) {
+    if (isReadonlyArray(table)) {
+        return table.map((it) => parseTableExpression(it));
+    }
+    else {
+        return [parseTableExpression(table)];
+    }
+}
+export function parseTableExpression(table) {
+    if (isString(table)) {
+        return parseAliasedTable(table);
+    }
+    else if (isAliasedDynamicTableBuilder(table)) {
+        return table.toOperationNode();
+    }
+    else {
+        return parseAliasedExpression(table);
+    }
+}
+export function parseAliasedTable(from) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
+    }
+    else {
+        return parseTable(from);
+    }
+}
+export function parseTable(from) {
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        return TableNode.createWithSchema(schema, table);
+    }
+    else {
+        return TableNode.create(from);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

package/.output/server/node_modules/kysely/dist/esm/parser/top-parser.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-parser.d.ts" />
+import { TopNode } from '../operation-node/top-node.js';
+import { isBigInt, isNumber, isUndefined } from '../util/object-utils.js';
+export function parseTop(expression, modifiers) {
+    if (!isNumber(expression) && !isBigInt(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!isUndefined(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}