@lucidcms/plugin-pages
Version:
The official Pages plugin for Lucid CMS
1,974 lines • 166 kB
JavaScript
import { copy, logger, z } from "@lucidcms/core";
import { buildTableName, copy as copy$1, prefixGeneratedColName } from "@lucidcms/core/plugin";
import { inspect } from "node:util";
//#region src/constants.ts
const PLUGIN_KEY = "plugin-pages";
const LUCID_VERSION = "0.x.x";
var constants_default = { fields: {
parentPage: { key: "parentPage" },
slug: { key: "slug" },
fullSlug: { key: "fullSlug" }
} };
//#endregion
//#region src/utils/get-parent-page-id.ts
/**
* Returns the single parent page ID used by the pages plugin.
*/
const getParentPageId = (field) => {
if (!Array.isArray(field.value)) return null;
const parentPageValue = field.value[0];
if (typeof parentPageValue !== "object" || parentPageValue === null) return null;
if (!("id" in parentPageValue)) return null;
return typeof parentPageValue.id === "number" ? parentPageValue.id : null;
};
//#endregion
//#region src/utils/normalize-path-value.ts
const normalizePathValue = (value) => {
if (value === null || value === void 0) return value;
if (value === "/") return "/";
return value.toLowerCase();
};
//#endregion
//#region src/utils/format-fullslug.ts
const formatFullSlug = (...parts) => {
const hasRoot = parts.some((part) => part === "/");
const normalizedParts = parts.map((part) => normalizePathValue(part)).filter((part) => part !== null && part !== void 0).map((part) => {
if (part === "/") return "";
return part.replace(/^\/+|\/+$/g, "");
}).filter(Boolean);
if (normalizedParts.length === 0) return hasRoot ? "/" : null;
return `/${normalizedParts.join("/")}`.replace(/\/+/g, "/");
};
//#endregion
//#region src/utils/build-fullslug-from-fullslug.ts
const buildFullSlug = (data) => {
if (data.slug === null || data.slug === void 0 || data.slug.trim() === "") return null;
const targetParentFullSlugField = data.parentFields.find((field) => {
return field.locale === data.targetLocale;
});
if (targetParentFullSlugField?._fullSlug) return formatFullSlug(targetParentFullSlugField._fullSlug, data.slug);
return formatFullSlug(data.prefix, data.slug);
};
//#endregion
//#region src/utils/resolve-collection-prefix.ts
const normalizePrefix = (prefix) => {
const normalizedPrefix = normalizePathValue(prefix);
if (!normalizedPrefix) return void 0;
const trimmed = normalizedPrefix.replace(/^\/+|\/+$/g, "");
return trimmed.length > 0 ? trimmed : void 0;
};
const resolveCollectionPrefix = (data) => {
if (!data.collection.prefix) return void 0;
if (typeof data.collection.prefix === "string") return normalizePrefix(data.collection.prefix);
return normalizePrefix(data.collection.prefix[data.localeCode]);
};
//#endregion
//#region src/services/construct-parent-fullslug.ts
/**
* Constructs the fullSlug from the slug and parentPage fields
*/
const constructParentFullSlug = (data) => {
const fullSlug = data.localization.locales.reduce((acc, locale) => {
acc[locale.code] = null;
return acc;
}, {});
if (data.collection.localized && data.fields.slug.translations) for (let i = 0; i < data.localization.locales.length; i++) {
const locale = data.localization.locales[i];
if (!locale) continue;
fullSlug[locale.code] = buildFullSlug({
parentFields: data.parentFields || [],
targetLocale: locale.code,
slug: data.fields.slug.translations[locale.code],
prefix: resolveCollectionPrefix({
collection: data.collection,
localeCode: locale.code
})
});
}
else fullSlug[data.localization.defaultLocale] = buildFullSlug({
parentFields: data.parentFields || [],
targetLocale: data.localization.defaultLocale,
slug: data.fields.slug.value,
prefix: resolveCollectionPrefix({
collection: data.collection,
localeCode: data.localization.defaultLocale
})
});
return {
error: void 0,
data: fullSlug
};
};
//#endregion
//#region ../../node_modules/kysely/dist/util/object-utils.js
function isUndefined(obj) {
return typeof obj === "undefined" || obj === void 0;
}
function isString(obj) {
return typeof obj === "string";
}
function isNumber(obj) {
return typeof obj === "number";
}
function isBoolean(obj) {
return typeof obj === "boolean";
}
function isNull(obj) {
return obj === null;
}
function isBigInt(obj) {
return typeof obj === "bigint";
}
function isFunction(obj) {
return typeof obj === "function";
}
function isObject(obj) {
return typeof obj === "object" && obj !== null;
}
function freeze(obj) {
return Object.freeze(obj);
}
function asArray(arg) {
if (isReadonlyArray(arg)) return arg;
else return [arg];
}
function isReadonlyArray(arg) {
return Array.isArray(arg);
}
function getMessage(error) {
return error instanceof Error ? error.message : String(error);
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/identifier-node.js
/**
* @internal
*/
const IdentifierNode = freeze({
is(node) {
return node.kind === "IdentifierNode";
},
create(name) {
return freeze({
kind: "IdentifierNode",
name
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/schemable-identifier-node.js
/**
* @internal
*/
const SchemableIdentifierNode = freeze({
is(node) {
return node.kind === "SchemableIdentifierNode";
},
create(identifier) {
return freeze({
kind: "SchemableIdentifierNode",
identifier: IdentifierNode.create(identifier)
});
},
createWithSchema(schema, identifier) {
return freeze({
kind: "SchemableIdentifierNode",
schema: IdentifierNode.create(schema),
identifier: IdentifierNode.create(identifier)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/alias-node.js
/**
* @internal
*/
const AliasNode = freeze({
is(node) {
return node.kind === "AliasNode";
},
create(node, alias) {
return freeze({
kind: "AliasNode",
node,
alias
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/table-node.js
/**
* @internal
*/
const TableNode = freeze({
is(node) {
return node.kind === "TableNode";
},
create(table) {
return freeze({
kind: "TableNode",
table: SchemableIdentifierNode.create(table)
});
},
createWithSchema(schema, table) {
return freeze({
kind: "TableNode",
table: SchemableIdentifierNode.createWithSchema(schema, table)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/operation-node-source.js
function isOperationNodeSource(obj) {
return isObject(obj) && isFunction(obj.toOperationNode);
}
//#endregion
//#region ../../node_modules/kysely/dist/expression/expression.js
function isExpression(obj) {
return isObject(obj) && "expressionType" in obj && isOperationNodeSource(obj);
}
function isAliasedExpression(obj) {
return isObject(obj) && "expression" in obj && isString(obj.alias) && isOperationNodeSource(obj);
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/select-modifier-node.js
/**
* @internal
*/
const SelectModifierNode = freeze({
is(node) {
return node.kind === "SelectModifierNode";
},
create(modifier, of) {
return freeze({
kind: "SelectModifierNode",
modifier,
of
});
},
createWithExpression(modifier) {
return freeze({
kind: "SelectModifierNode",
rawModifier: modifier
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/and-node.js
/**
* @internal
*/
const AndNode = freeze({
is(node) {
return node.kind === "AndNode";
},
create(left, right) {
return freeze({
kind: "AndNode",
left,
right
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/or-node.js
/**
* @internal
*/
const OrNode = freeze({
is(node) {
return node.kind === "OrNode";
},
create(left, right) {
return freeze({
kind: "OrNode",
left,
right
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/on-node.js
/**
* @internal
*/
const OnNode = freeze({
is(node) {
return node.kind === "OnNode";
},
create(filter) {
return freeze({
kind: "OnNode",
on: filter
});
},
cloneWithOperation(onNode, operator, operation) {
return freeze({
...onNode,
on: operator === "And" ? AndNode.create(onNode.on, operation) : OrNode.create(onNode.on, operation)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/join-node.js
/**
* @internal
*/
const JoinNode = freeze({
is(node) {
return node.kind === "JoinNode";
},
create(joinType, table) {
return freeze({
kind: "JoinNode",
joinType,
table,
on: void 0
});
},
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)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/binary-operation-node.js
/**
* @internal
*/
const BinaryOperationNode = freeze({
is(node) {
return node.kind === "BinaryOperationNode";
},
create(leftOperand, operator, rightOperand) {
return freeze({
kind: "BinaryOperationNode",
leftOperand,
operator,
rightOperand
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/operator-node.js
const COMPARISON_OPERATORS_DICTIONARY = freeze({
"=": true,
"==": true,
"!=": true,
"<>": true,
">": true,
">=": true,
"<": true,
"<=": true,
in: true,
"not in": true,
is: true,
"is not": true,
like: true,
"not like": true,
match: true,
ilike: true,
"not ilike": true,
"@>": true,
"<@": true,
"^@": true,
"&&": true,
"?": true,
"?&": true,
"?|": true,
"!<": true,
"!>": true,
"<=>": true,
"!~": true,
"~": true,
"~*": true,
"!~*": true,
"@@": true,
"@@@": true,
"!!": true,
"<->": true,
regexp: true,
"is distinct from": true,
"is not distinct from": true
});
Object.keys(COMPARISON_OPERATORS_DICTIONARY);
const ARITHMETIC_OPERATORS_DICTIONARY = freeze({
"+": true,
"-": true,
"*": true,
"/": true,
"%": true,
"^": true,
"&": true,
"|": true,
"#": true,
"<<": true,
">>": true
});
Object.keys(ARITHMETIC_OPERATORS_DICTIONARY);
const JSON_OPERATORS_DICTIONARY = freeze({
"->": true,
"->>": true
});
/**
* @deprecated will be removed in version 0.30.x
*/
const JSON_OPERATORS = Object.keys(JSON_OPERATORS_DICTIONARY);
const BINARY_OPERATORS_DICTIONARY = freeze({
...COMPARISON_OPERATORS_DICTIONARY,
...ARITHMETIC_OPERATORS_DICTIONARY,
"||": true
});
/**
* @deprecated will be removed in version 0.30.x
*/
const BINARY_OPERATORS = Object.keys(BINARY_OPERATORS_DICTIONARY);
const UNARY_FILTER_OPERATORS_DICTIONARY = freeze({
exists: true,
"not exists": true
});
Object.keys(UNARY_FILTER_OPERATORS_DICTIONARY);
const UNARY_OPERATORS_DICTIONARY = freeze({
...UNARY_FILTER_OPERATORS_DICTIONARY,
"-": true,
not: true
});
/**
* @deprecated will be removed in version 0.30.x
*/
const UNARY_OPERATORS = Object.keys(UNARY_OPERATORS_DICTIONARY);
[
...BINARY_OPERATORS,
...JSON_OPERATORS,
...UNARY_OPERATORS
];
/**
* @internal
*/
const OperatorNode = freeze({
is(node) {
return node.kind === "OperatorNode";
},
create(operator) {
return freeze({
kind: "OperatorNode",
operator
});
}
});
function isBinaryOperator(op) {
return isString(op) && BINARY_OPERATORS_DICTIONARY[op];
}
function isJSONOperator(op) {
return isString(op) && JSON_OPERATORS_DICTIONARY[op];
}
function isUnaryOperator(op) {
return isString(op) && UNARY_OPERATORS_DICTIONARY[op];
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/column-node.js
/**
* @internal
*/
const ColumnNode = freeze({
is(node) {
return node.kind === "ColumnNode";
},
create(column) {
return freeze({
kind: "ColumnNode",
column: IdentifierNode.create(column)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/select-all-node.js
/**
* @internal
*/
const SelectAllNode = freeze({
is(node) {
return node.kind === "SelectAllNode";
},
create() {
return freeze({ kind: "SelectAllNode" });
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/reference-node.js
/**
* @internal
*/
const ReferenceNode = freeze({
is(node) {
return node.kind === "ReferenceNode";
},
create(column, table) {
return freeze({
kind: "ReferenceNode",
table,
column
});
},
createSelectAll(table) {
return freeze({
kind: "ReferenceNode",
table,
column: SelectAllNode.create()
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/dynamic/dynamic-reference-builder.js
function isDynamicReferenceBuilder(obj) {
return isObject(obj) && isOperationNodeSource(obj) && isString(obj.dynamicReference);
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/order-by-item-node.js
/**
* @internal
*/
const OrderByItemNode = freeze({
is(node) {
return node.kind === "OrderByItemNode";
},
create(orderBy, direction) {
return freeze({
kind: "OrderByItemNode",
orderBy,
direction
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/raw-node.js
/**
* @internal
*/
const RawNode = freeze({
is(node) {
return node.kind === "RawNode";
},
create(sqlFragments, parameters) {
return freeze({
kind: "RawNode",
sqlFragments: freeze(sqlFragments),
parameters: freeze(parameters)
});
},
createWithSql(sql) {
return RawNode.create([sql], []);
},
createWithChild(child) {
return RawNode.create(["", ""], [child]);
},
createWithChildren(children) {
return RawNode.create(new Array(children.length + 1).fill(""), children);
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/collate-node.js
/**
* @internal
*/
const CollateNode = freeze({
is(node) {
return node.kind === "CollateNode";
},
create(collation) {
return freeze({
kind: "CollateNode",
collation: IdentifierNode.create(collation)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/query-builder/order-by-item-builder.js
var OrderByItemBuilder = class OrderByItemBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
/**
* Adds `desc` to the `order by` item.
*
* See {@link asc} for the opposite.
*/
desc() {
return new OrderByItemBuilder({ node: OrderByItemNode.cloneWith(this.#props.node, { direction: RawNode.createWithSql("desc") }) });
}
/**
* Adds `asc` to the `order by` item.
*
* See {@link desc} for the opposite.
*/
asc() {
return new OrderByItemBuilder({ node: OrderByItemNode.cloneWith(this.#props.node, { direction: RawNode.createWithSql("asc") }) });
}
/**
* Adds `nulls last` to the `order by` item.
*
* This is only supported by some dialects like PostgreSQL and SQLite.
*
* See {@link nullsFirst} for the opposite.
*/
nullsLast() {
return new OrderByItemBuilder({ node: OrderByItemNode.cloneWith(this.#props.node, { nulls: "last" }) });
}
/**
* Adds `nulls first` to the `order by` item.
*
* This is only supported by some dialects like PostgreSQL and SQLite.
*
* See {@link nullsLast} for the opposite.
*/
nullsFirst() {
return new OrderByItemBuilder({ node: OrderByItemNode.cloneWith(this.#props.node, { nulls: "first" }) });
}
/**
* Adds `collate <collationName>` to the `order by` item.
*/
collate(collation) {
return new OrderByItemBuilder({ node: OrderByItemNode.cloneWith(this.#props.node, { collation: CollateNode.create(collation) }) });
}
toOperationNode() {
return this.#props.node;
}
};
//#endregion
//#region ../../node_modules/kysely/dist/util/log-once.js
const LOGGED_MESSAGES = /* @__PURE__ */ new Set();
/**
* Use for system-level logging, such as deprecation messages.
* Logs a message and ensures it won't be logged again.
*/
function logOnce(message) {
if (LOGGED_MESSAGES.has(message)) return;
LOGGED_MESSAGES.add(message);
console.log(message);
}
//#endregion
//#region ../../node_modules/kysely/dist/parser/order-by-parser.js
function isOrderByDirection(thing) {
return thing === "asc" || thing === "desc";
}
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}`);
}
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();
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/json-reference-node.js
/**
* @internal
*/
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
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/json-operator-chain-node.js
/**
* @internal
*/
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])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/json-path-node.js
/**
* @internal
*/
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])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/reference-parser.js
function parseSimpleReferenceExpression(exp) {
if (isString(exp)) return parseStringReference(exp);
return exp.toOperationNode();
}
function parseReferenceExpressionOrList(arg) {
if (isReadonlyArray(arg)) return arg.map((it) => parseReferenceExpression(it));
else return [parseReferenceExpression(arg)];
}
function parseReferenceExpression(exp) {
if (isExpressionOrFactory(exp)) return parseExpression(exp);
return parseSimpleReferenceExpression(exp);
}
function parseJSONReference(ref, op) {
if (isJSONOperator(op)) return JSONReferenceNode.create(parseStringReference(ref), JSONOperatorChainNode.create(OperatorNode.create(op)));
if (op === "->$" || op === "->>$") return JSONReferenceNode.create(parseStringReference(ref), JSONPathNode.create(OperatorNode.create(op.slice(0, -1))));
throw new Error(`Invalid JSON operator: ${op}`);
}
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$1);
if (parts.length === 3) return parseStringReferenceWithTableAndSchema(parts);
if (parts.length === 2) return parseStringReferenceWithTable(parts);
throw new Error(`invalid column reference ${ref}`);
}
function parseAliasedStringReference(ref) {
const ALIAS_SEPARATOR = " as ";
if (ref.includes(ALIAS_SEPARATOR)) {
const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim$1);
return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
} else return parseStringReference(ref);
}
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$1(str) {
return str.trim();
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/primitive-value-list-node.js
/**
* @internal
*/
const PrimitiveValueListNode = freeze({
is(node) {
return node.kind === "PrimitiveValueListNode";
},
create(values) {
return freeze({
kind: "PrimitiveValueListNode",
values: freeze([...values])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/value-list-node.js
/**
* @internal
*/
const ValueListNode = freeze({
is(node) {
return node.kind === "ValueListNode";
},
create(values) {
return freeze({
kind: "ValueListNode",
values: freeze(values)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/value-node.js
/**
* @internal
*/
const ValueNode = freeze({
is(node) {
return node.kind === "ValueNode";
},
create(value) {
return freeze({
kind: "ValueNode",
value
});
},
createImmediate(value) {
return freeze({
kind: "ValueNode",
value,
immediate: true
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/value-parser.js
function parseValueExpressionOrList(arg) {
if (isReadonlyArray(arg)) return parseValueExpressionList(arg);
return parseValueExpression(arg);
}
function parseValueExpression(exp) {
if (isExpressionOrFactory(exp)) return parseExpression(exp);
return ValueNode.create(exp);
}
function isSafeImmediateValue(value) {
return isNumber(value) || isBoolean(value) || isNull(value);
}
function parseSafeImmediateValue(value) {
if (!isSafeImmediateValue(value)) throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
return ValueNode.createImmediate(value);
}
function parseValueExpressionList(arg) {
if (arg.some(isExpressionOrFactory)) return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
return PrimitiveValueListNode.create(arg);
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/parens-node.js
/**
* @internal
*/
const ParensNode = freeze({
is(node) {
return node.kind === "ParensNode";
},
create(node) {
return freeze({
kind: "ParensNode",
node
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/binary-operation-parser.js
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)}`);
}
function parseValueBinaryOperation(left, operator, right) {
if (isIsOperator(operator) && needsIsOperator(right)) return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), ValueNode.createImmediate(right));
return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), parseValueExpressionOrList(right));
}
function parseReferentialBinaryOperation(left, operator, right) {
return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), parseReferenceExpression(right));
}
function parseFilterObject(obj, combinator) {
return parseFilterList(Object.entries(obj).filter(([, v]) => !isUndefined(v)).map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? "is" : "=", v)), combinator);
}
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 parseBinaryOperator(operator) {
if (isBinaryOperator(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;
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/order-by-node.js
/**
* @internal
*/
const OrderByNode = freeze({
is(node) {
return node.kind === "OrderByNode";
},
create(items) {
return freeze({
kind: "OrderByNode",
items: freeze([...items])
});
},
cloneWithItems(orderBy, items) {
return freeze({
...orderBy,
items: freeze([...orderBy.items, ...items])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/partition-by-node.js
/**
* @internal
*/
const PartitionByNode = freeze({
is(node) {
return node.kind === "PartitionByNode";
},
create(items) {
return freeze({
kind: "PartitionByNode",
items: freeze(items)
});
},
cloneWithItems(partitionBy, items) {
return freeze({
...partitionBy,
items: freeze([...partitionBy.items, ...items])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/over-node.js
/**
* @internal
*/
const OverNode = freeze({
is(node) {
return node.kind === "OverNode";
},
create() {
return freeze({ kind: "OverNode" });
},
cloneWithOrderByItems(overNode, items) {
return freeze({
...overNode,
orderBy: overNode.orderBy ? OrderByNode.cloneWithItems(overNode.orderBy, items) : OrderByNode.create(items)
});
},
cloneWithPartitionByItems(overNode, items) {
return freeze({
...overNode,
partitionBy: overNode.partitionBy ? PartitionByNode.cloneWithItems(overNode.partitionBy, items) : PartitionByNode.create(items)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/from-node.js
/**
* @internal
*/
const FromNode = freeze({
is(node) {
return node.kind === "FromNode";
},
create(froms) {
return freeze({
kind: "FromNode",
froms: freeze(froms)
});
},
cloneWithFroms(from, froms) {
return freeze({
...from,
froms: freeze([...from.froms, ...froms])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/group-by-node.js
/**
* @internal
*/
const GroupByNode = freeze({
is(node) {
return node.kind === "GroupByNode";
},
create(items) {
return freeze({
kind: "GroupByNode",
items: freeze(items)
});
},
cloneWithItems(groupBy, items) {
return freeze({
...groupBy,
items: freeze([...groupBy.items, ...items])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/having-node.js
/**
* @internal
*/
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)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/insert-query-node.js
/**
* @internal
*/
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
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/list-node.js
/**
* @internal
*/
const ListNode = freeze({
is(node) {
return node.kind === "ListNode";
},
create(items) {
return freeze({
kind: "ListNode",
items: freeze(items)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/update-query-node.js
/**
* @internal
*/
const UpdateQueryNode = freeze({
is(node) {
return node.kind === "UpdateQueryNode";
},
create(tables, withNode) {
return freeze({
kind: "UpdateQueryNode",
table: tables.length === 1 ? tables[0] : ListNode.create(tables),
...withNode && { with: withNode }
});
},
createWithoutTable() {
return freeze({ kind: "UpdateQueryNode" });
},
cloneWithFromItems(updateQuery, fromItems) {
return freeze({
...updateQuery,
from: updateQuery.from ? FromNode.cloneWithFroms(updateQuery.from, fromItems) : FromNode.create(fromItems)
});
},
cloneWithUpdates(updateQuery, updates) {
return freeze({
...updateQuery,
updates: updateQuery.updates ? freeze([...updateQuery.updates, ...updates]) : updates
});
},
cloneWithLimit(updateQuery, limit) {
return freeze({
...updateQuery,
limit
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/using-node.js
/**
* @internal
*/
const UsingNode = freeze({
is(node) {
return node.kind === "UsingNode";
},
create(tables) {
return freeze({
kind: "UsingNode",
tables: freeze(tables)
});
},
cloneWithTables(using, tables) {
return freeze({
...using,
tables: freeze([...using.tables, ...tables])
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/delete-query-node.js
/**
* @internal
*/
const DeleteQueryNode = freeze({
is(node) {
return node.kind === "DeleteQueryNode";
},
create(fromItems, withNode) {
return freeze({
kind: "DeleteQueryNode",
from: FromNode.create(fromItems),
...withNode && { with: withNode }
});
},
/**
* @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
*/
cloneWithOrderByItems: (node, items) => QueryNode.cloneWithOrderByItems(node, items),
/**
* @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
*/
cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
cloneWithLimit(deleteNode, limit) {
return freeze({
...deleteNode,
limit
});
},
cloneWithoutLimit(deleteNode) {
return freeze({
...deleteNode,
limit: void 0
});
},
cloneWithUsing(deleteNode, tables) {
return freeze({
...deleteNode,
using: deleteNode.using !== void 0 ? UsingNode.cloneWithTables(deleteNode.using, tables) : UsingNode.create(tables)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/where-node.js
/**
* @internal
*/
const WhereNode = freeze({
is(node) {
return node.kind === "WhereNode";
},
create(filter) {
return freeze({
kind: "WhereNode",
where: filter
});
},
cloneWithOperation(whereNode, operator, operation) {
return freeze({
...whereNode,
where: operator === "And" ? AndNode.create(whereNode.where, operation) : OrNode.create(whereNode.where, operation)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/returning-node.js
/**
* @internal
*/
const ReturningNode = freeze({
is(node) {
return node.kind === "ReturningNode";
},
create(selections) {
return freeze({
kind: "ReturningNode",
selections: freeze(selections)
});
},
cloneWithSelections(returning, selections) {
return freeze({
...returning,
selections: returning.selections ? freeze([...returning.selections, ...selections]) : freeze(selections)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/explain-node.js
/**
* @internal
*/
const ExplainNode = freeze({
is(node) {
return node.kind === "ExplainNode";
},
create(format, options) {
return freeze({
kind: "ExplainNode",
format,
options
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/when-node.js
/**
* @internal
*/
const WhenNode = freeze({
is(node) {
return node.kind === "WhenNode";
},
create(condition) {
return freeze({
kind: "WhenNode",
condition
});
},
cloneWithResult(whenNode, result) {
return freeze({
...whenNode,
result
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/merge-query-node.js
/**
* @internal
*/
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)]) : void 0
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/output-node.js
/**
* @internal
*/
const OutputNode = freeze({
is(node) {
return node.kind === "OutputNode";
},
create(selections) {
return freeze({
kind: "OutputNode",
selections: freeze(selections)
});
},
cloneWithSelections(output, selections) {
return freeze({
...output,
selections: output.selections ? freeze([...output.selections, ...selections]) : freeze(selections)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/query-node.js
/**
* @internal
*/
const QueryNode = freeze({
is(node) {
return SelectQueryNode.is(node) || InsertQueryNode.is(node) || UpdateQueryNode.is(node) || DeleteQueryNode.is(node) || MergeQueryNode.is(node);
},
cloneWithEndModifier(node, modifier) {
return freeze({
...node,
endModifiers: node.endModifiers ? freeze([...node.endModifiers, modifier]) : freeze([modifier])
});
},
cloneWithWhere(node, operation) {
return freeze({
...node,
where: node.where ? WhereNode.cloneWithOperation(node.where, "And", operation) : WhereNode.create(operation)
});
},
cloneWithJoin(node, join) {
return freeze({
...node,
joins: node.joins ? freeze([...node.joins, join]) : freeze([join])
});
},
cloneWithReturning(node, selections) {
return freeze({
...node,
returning: node.returning ? ReturningNode.cloneWithSelections(node.returning, selections) : ReturningNode.create(selections)
});
},
cloneWithoutReturning(node) {
return freeze({
...node,
returning: void 0
});
},
cloneWithoutWhere(node) {
return freeze({
...node,
where: void 0
});
},
cloneWithExplain(node, format, options) {
return freeze({
...node,
explain: ExplainNode.create(format, options?.toOperationNode())
});
},
cloneWithTop(node, top) {
return freeze({
...node,
top
});
},
cloneWithOutput(node, selections) {
return freeze({
...node,
output: node.output ? OutputNode.cloneWithSelections(node.output, selections) : OutputNode.create(selections)
});
},
cloneWithOrderByItems(node, items) {
return freeze({
...node,
orderBy: node.orderBy ? OrderByNode.cloneWithItems(node.orderBy, items) : OrderByNode.create(items)
});
},
cloneWithoutOrderBy(node) {
return freeze({
...node,
orderBy: void 0
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/select-query-node.js
/**
* @internal
*/
const SelectQueryNode = freeze({
is(node) {
return node.kind === "SelectQueryNode";
},
create(withNode) {
return freeze({
kind: "SelectQueryNode",
...withNode && { with: withNode }
});
},
createFrom(fromItems, withNode) {
return freeze({
kind: "SelectQueryNode",
from: FromNode.create(fromItems),
...withNode && { with: withNode }
});
},
cloneWithSelections(select, selections) {
return freeze({
...select,
selections: select.selections ? freeze([...select.selections, ...selections]) : freeze(selections)
});
},
cloneWithDistinctOn(select, expressions) {
return freeze({
...select,
distinctOn: select.distinctOn ? freeze([...select.distinctOn, ...expressions]) : freeze(expressions)
});
},
cloneWithFrontModifier(select, modifier) {
return freeze({
...select,
frontModifiers: select.frontModifiers ? freeze([...select.frontModifiers, modifier]) : freeze([modifier])
});
},
/**
* @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
*/
cloneWithOrderByItems: (node, items) => QueryNode.cloneWithOrderByItems(node, items),
cloneWithGroupByItems(selectNode, items) {
return freeze({
...selectNode,
groupBy: selectNode.groupBy ? GroupByNode.cloneWithItems(selectNode.groupBy, items) : GroupByNode.create(items)
});
},
cloneWithLimit(selectNode, limit) {
return freeze({
...selectNode,
limit
});
},
cloneWithOffset(selectNode, offset) {
return freeze({
...selectNode,
offset
});
},
cloneWithFetch(selectNode, fetch) {
return freeze({
...selectNode,
fetch
});
},
cloneWithHaving(selectNode, operation) {
return freeze({
...selectNode,
having: selectNode.having ? HavingNode.cloneWithOperation(selectNode.having, "And", operation) : HavingNode.create(operation)
});
},
cloneWithSetOperations(selectNode, setOperations) {
return freeze({
...selectNode,
setOperations: selectNode.setOperations ? freeze([...selectNode.setOperations, ...setOperations]) : freeze([...setOperations])
});
},
cloneWithoutSelections(select) {
return freeze({
...select,
selections: []
});
},
cloneWithoutLimit(select) {
return freeze({
...select,
limit: void 0
});
},
cloneWithoutOffset(select) {
return freeze({
...select,
offset: void 0
});
},
/**
* @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
*/
cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
cloneWithoutGroupBy(select) {
return freeze({
...select,
groupBy: void 0
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/query-builder/join-builder.js
var JoinBuilder = class JoinBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
on(...args) {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseValueBinaryOperationOrExpression(args))
});
}
/**
* Just like {@link WhereInterface.whereRef} but adds an item to the join's
* `on` clause instead.
*
* See {@link WhereInterface.whereRef} for documentation and examples.
*/
onRef(lhs, op, rhs) {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
/**
* Adds `on true`.
*/
onTrue() {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, RawNode.createWithSql("true"))
});
}
/**
* Simply calls the provided function passing `this` as the only argument. `$call` returns
* what the provided function returns.
*/
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.joinNode;
}
};
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/partition-by-item-node.js
/**
* @internal
*/
const PartitionByItemNode = freeze({
is(node) {
return node.kind === "PartitionByItemNode";
},
create(partitionBy) {
return freeze({
kind: "PartitionByItemNode",
partitionBy
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/partition-by-parser.js
function parsePartitionBy(partitionBy) {
return parseReferenceExpressionOrList(partitionBy).map(PartitionByItemNode.create);
}
//#endregion
//#region ../../node_modules/kysely/dist/query-builder/over-builder.js
var OverBuilder = class OverBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
orderBy(...args) {
return new OverBuilder({ overNode: OverNode.cloneWithOrderByItems(this.#props.overNode, parseOrderBy(args)) });
}
clearOrderBy() {
return new OverBuilder({ overNode: QueryNode.cloneWithoutOrderBy(this.#props.overNode) });
}
partitionBy(partitionBy) {
return new OverBuilder({ overNode: OverNode.cloneWithPartitionByItems(this.#props.overNode, parsePartitionBy(partitionBy)) });
}
/**
* Simply calls the provided function passing `this` as the only argument. `$call` returns
* what the provided function returns.
*/
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.overNode;
}
};
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/selection-node.js
/**
* @internal
*/
const SelectionNode = freeze({
is(node) {
return node.kind === "SelectionNode";
},
create(selection) {
return freeze({
kind: "SelectionNode",
selection
});
},
createSelectAll() {
return freeze({
kind: "SelectionNode",
selection: SelectAllNode.create()
});
},
createSelectAllFromTable(table) {
return freeze({
kind: "SelectionNode",
selection: ReferenceNode.createSelectAll(table)
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/select-parser.js
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));
}
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)}`);
}
//#endregion
//#region ../../node_modules/kysely/dist/query-builder/no-result-error.js
var NoResultError = class extends Error {
/**
* The operation node tree of the query that was executed.
*/
node;
constructor(node) {
super("no result");
this.node = node;
}
};
function isNoResultErrorConstructor(fn) {
return Object.prototype.hasOwnProperty.call(fn, "prototype");
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/top-node.js
/**
* @internal
*/
const TopNode = freeze({
is(node) {
return node.kind === "TopNode";
},
create(expression, modifiers) {
return freeze({
kind: "TopNode",
expression,
modifiers
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/parser/top-parser.js
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";
}
//#endregion
//#region ../../node_modules/kysely/dist/operation-node/limit-node.js
/**
* @internal
*/
const LimitNode = freeze({
is(node) {
return node.kind === "LimitNode";
},
create(limit) {
return freeze({
kind: "LimitNode",
limit
});
}
});
//#endregion
//#region ../../node_modules/kysely/dist/util/random-string.js
const CHARS = [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
];
function randomString(length) {
let chars = "";
for (let i = 0; i < length; ++i) chars += randomChar();
return chars;
}
function randomChar() {
return CHARS[~~(Math.random() * CHARS.length)];
}
//#endregion
//#region ../../node_modules/kysely/dist/util/query-id.js
function createQueryId() {
return new LazyQueryId();
}
var LazyQueryId = class {
#queryId;
get queryId() {
if (this.#queryId === void 0) this.#queryId = randomString(8);
return this.#queryId;
}
};
//#endregion
//#region ../../node_modules/kysely/dist/util/deferred.js
var Deferred = class {
#promise;
#resolve;
#reject;
constructor() {
this.#promise = new Promise((resolve, reject) => {
this.#reject = reject;
this.#resolve = resolve;
});
}
get promise() {
return this.#promise;
}
resolve = (value) => {
this.#resolve?.(value);
this.#resolve = this.#reject = void 0;
};
reject = (reason) => {
this.#reject?.(reason);
this.#reject = this.#resolve = void 0;
};
};
//#endregion
//#region ../../node_modules/kysely/dist/util/provide-controlled-connection.js
async function provideControlledConnection(connectionProvider, options) {
const connectionDefer = new Deferred();
const connectionReleaseDefer = new Deferred();
connectionProvider.provideConnection(async (connection) => {
connectionDefer.resolve(connection);
return await connectionReleaseDefer.promise;
}, options).catch((ex) => connectionDefer.reject(ex));
return freeze({
connection: await connectionDefer.promise,
release: connectionReleaseDefer.resolve
});
}
//#endregion
//#region ../../node_modules/kysely/dist/util/abort.js
function getInflightQueryAbortHandler(abortStrategy = "ignore query", connection, beforeThrow) {
if (abortStrategy === "ignore query") return;
if (abortStrategy === "cancel query") {
const handler = connection.cancelQuery;
if (!handler) throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.killSession ? "kill session" : void 0);
return handler.bind(connection);
}
if (abortStrategy === "kill session") {
const handler = connection.killSession;
if (!handler) throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.cancelQuery ? "cancel query" : void 0);
return handler.bind(connection);
}
beforeThrow();
throw new Error(`Unexpected \`inflightQueryAbortStrategy\`: "${abortStrategy}"`);
}
function throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, alt) {
throw new Error(`This dialect doesn't support \`inflightQueryAbortStrategy\` "${abortStrategy}". Use "ignore query"${alt ? ` or "${alt}"` : ""} instead.`);
}
function assertNotAborted(signal, timing, beforeThrow) {
if (signal?.aborted) {
beforeThrow?.();
throwReasonWithTiming(signal.reason, timing);
}
}
function throwReasonWithTiming(reason, timing) {
decorateWithTiming(reason, timing);
throw reason;
}
const ABORTED = {};
function printBackgroundFail(name) {
return (reason) => console.error(`\`${name}\` failed in the background after abortion: ${getMessage(reason)}`);
}
function decorateWithTiming(reason, timing) {
if (reason !== null && typeof reason === "object" && !Object.isFrozen(reason)) Object.defineProperty(reason, "__kysely_timing__", {
configurable: true,
enumerable: false,
value: timing,
writable: false
});
}
//#endregion
//#region ../../node_modules/kysely/dist/query-executor/query-executor-base.js
const NO_PLUGINS = freeze([]);
var QueryExecutorBase = class {
#plugins;
constructor(plugins = NO_PLUGINS) {
this.#plugins = plugins;
}
get plugins() {
return this.#plugins;
}
transformQuery(node, queryId) {
for (const plugin of this.#plugins) {
const transformedNode = plugin.transformQuery({
node,
queryId
});
if (transformedNode.kind === node.kind) node = transformedNode;
else throw new Error([
`KyselyPlugin.transformQuery must return a node`,
`of the same kind that was given to it.`,
`The plugin was given a ${node.kind}`,
`but it returned a ${transformedNode.kind}`
].join(" "));
}
return node;
}
async executeQuery(compiledQuery, options) {
const { inflightQueryAbortStrategy = "ignore query", signal } = options || {};
if (!signal) {
const result = await this.provideConnection(async (connection) => {
return await connection.executeQuery(compiledQuery);
}, options);
return await this.#transformResult(result, compiledQuery.queryId);
}
assertNotAborted(signal, "before query execution");
options = freeze({ signal });
const { connection, release } = await provideControlledConnection(this, options);
const controlConnectionProvider = this.provideConnection.bind(this);
const { promise: abortPromise, resolve } = new Deferred();
const abortListener = () => resolve(ABORTED);
signal.addEventListener("abort", abortListener, { once: true });
try {
assertNotAborted(signal, "before query execution", release);
const inflightQueryAbortHandler = getInflightQueryAbortHandler(inflightQueryAbortStrategy, connection, releas