sphica
Version:
Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.
13,134 lines • 392 kB
JavaScript
#!/usr/bin/env node
// server/src/capture.ts
import { spawn as spawn2 } from "node:child_process";
import fs8 from "node:fs";
import path9 from "node:path";
// server/src/codex-log.ts
import fs from "node:fs";
import path from "node:path";
var SESSION_META_BYTES = 256 * 1024;
var text = (v) => typeof v === "string" ? v : null;
function codexThread(input) {
const file = input.transcript_path;
if (typeof file !== "string" || !path.isAbsolute(file))
return null;
let fd;
try {
if (!fs.lstatSync(file).isFile())
return null;
fd = fs.openSync(file, "r");
const buffer = Buffer.alloc(SESSION_META_BYTES);
const read = fs.readSync(fd, buffer, 0, SESSION_META_BYTES, 0);
const end = buffer.subarray(0, read).indexOf(10);
if (end < 0)
return null;
const line = JSON.parse(buffer.subarray(0, end).toString("utf8"));
const payload = line?.payload;
if (line?.type !== "session_meta" || !payload || typeof payload !== "object" || Array.isArray(payload))
return null;
const source = payload.source;
return {
id: text(payload.id),
originator: text(payload.originator),
threadSource: text(payload.thread_source),
parent: text(payload.parent_thread_id),
subagent: source && typeof source === "object" ? text(source.subagent) : null
};
} catch {
return null;
} finally {
if (fd !== undefined)
fs.closeSync(fd);
}
}
var ownThread = (input, thread) => Boolean(input.session_id) && thread?.id === input.session_id && thread?.threadSource === "user";
var childThread = (input, thread) => input.session_id && thread?.threadSource === "subagent" && thread.parent === input.session_id && thread.id !== null && thread.id !== input.session_id && /^[\x21-\x7e]{1,200}$/.test(thread.id) ? thread.id : null;
// server/node_modules/kysely/dist/util/object-utils.js
function isUndefined(obj) {
return typeof obj === "undefined" || obj === undefined;
}
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 isDate(obj) {
return obj instanceof Date;
}
function isBigInt(obj) {
return typeof obj === "bigint";
}
function isFunction(obj) {
return typeof obj === "function";
}
function isObject(obj) {
return typeof obj === "object" && obj !== null;
}
function isPlainObject(obj) {
if (!isObject(obj) || getTag(obj) !== "[object Object]") {
return false;
}
if (Object.getPrototypeOf(obj) === null) {
return true;
}
let proto = obj;
while (Object.getPrototypeOf(proto) !== null) {
proto = Object.getPrototypeOf(proto);
}
return Object.getPrototypeOf(obj) === proto;
}
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 noop(obj) {
return obj;
}
function getMessage(error) {
return error instanceof Error ? error.message : String(error);
}
var toString = Object.prototype.toString;
function getTag(value) {
if (value == null) {
return value === undefined ? "[object Undefined]" : "[object Null]";
}
return toString.call(value);
}
// server/node_modules/kysely/dist/operation-node/alter-table-node.js
var AlterTableNode = freeze({
is(node) {
return node.kind === "AlterTableNode";
},
create(table) {
return freeze({
kind: "AlterTableNode",
table
});
},
cloneWithTableProps(node, props) {
return freeze({
...node,
...props
});
},
cloneWithColumnAlteration(node, columnAlteration) {
return freeze({
...node,
columnAlterations: node.columnAlterations ? [...node.columnAlterations, columnAlteration] : [columnAlteration]
});
}
});
// server/node_modules/kysely/dist/operation-node/identifier-node.js
var IdentifierNode = freeze({
is(node) {
return node.kind === "IdentifierNode";
},
create(name) {
return freeze({
kind: "IdentifierNode",
name
});
}
});
// server/node_modules/kysely/dist/operation-node/create-index-node.js
var CreateIndexNode = freeze({
is(node) {
return node.kind === "CreateIndexNode";
},
create(name) {
return freeze({
kind: "CreateIndexNode",
name: IdentifierNode.create(name)
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
},
cloneWithColumns(node, columns) {
return freeze({
...node,
columns: [...node.columns || [], ...columns]
});
}
});
// server/node_modules/kysely/dist/operation-node/create-schema-node.js
var CreateSchemaNode = freeze({
is(node) {
return node.kind === "CreateSchemaNode";
},
create(schema, params) {
return freeze({
kind: "CreateSchemaNode",
schema: IdentifierNode.create(schema),
...params
});
},
cloneWith(createSchema, params) {
return freeze({
...createSchema,
...params
});
}
});
// server/node_modules/kysely/dist/operation-node/create-table-node.js
var ON_COMMIT_ACTIONS = ["preserve rows", "delete rows", "drop"];
var CreateTableNode = freeze({
is(node) {
return node.kind === "CreateTableNode";
},
create(table) {
return freeze({
kind: "CreateTableNode",
table,
columns: freeze([])
});
},
cloneWithColumn(node, column) {
return freeze({
...node,
columns: freeze([...node.columns, column])
});
},
cloneWithConstraint(node, constraint) {
return freeze({
...node,
constraints: node.constraints ? freeze([...node.constraints, constraint]) : freeze([constraint])
});
},
cloneWithIndex(node, index) {
return freeze({
...node,
indexes: node.indexes ? freeze([...node.indexes, index]) : freeze([index])
});
},
cloneWithFrontModifier(node, modifier) {
return freeze({
...node,
frontModifiers: node.frontModifiers ? freeze([...node.frontModifiers, modifier]) : freeze([modifier])
});
},
cloneWithEndModifier(node, modifier) {
return freeze({
...node,
endModifiers: node.endModifiers ? freeze([...node.endModifiers, modifier]) : freeze([modifier])
});
},
cloneWith(node, params) {
return freeze({
...node,
...params
});
}
});
// server/node_modules/kysely/dist/operation-node/schemable-identifier-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/drop-index-node.js
var DropIndexNode = freeze({
is(node) {
return node.kind === "DropIndexNode";
},
create(name, params) {
return freeze({
kind: "DropIndexNode",
name: SchemableIdentifierNode.create(name),
...params
});
},
cloneWith(dropIndex, props) {
return freeze({
...dropIndex,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/drop-schema-node.js
var DropSchemaNode = freeze({
is(node) {
return node.kind === "DropSchemaNode";
},
create(schema, params) {
return freeze({
kind: "DropSchemaNode",
schema: IdentifierNode.create(schema),
...params
});
},
cloneWith(dropSchema, params) {
return freeze({
...dropSchema,
...params
});
}
});
// server/node_modules/kysely/dist/operation-node/drop-table-node.js
var DropTableNode = freeze({
is(node) {
return node.kind === "DropTableNode";
},
create(table, params) {
return freeze({
kind: "DropTableNode",
table,
...params
});
},
cloneWith(dropIndex, params) {
return freeze({
...dropIndex,
...params
});
}
});
// server/node_modules/kysely/dist/operation-node/alias-node.js
var AliasNode = freeze({
is(node) {
return node.kind === "AliasNode";
},
create(node, alias) {
return freeze({
kind: "AliasNode",
node,
alias
});
}
});
// server/node_modules/kysely/dist/operation-node/table-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/operation-node-source.js
function isOperationNodeSource(obj) {
return isObject(obj) && isFunction(obj.toOperationNode);
}
// server/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);
}
// server/node_modules/kysely/dist/operation-node/select-modifier-node.js
var 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
});
}
});
// server/node_modules/kysely/dist/operation-node/and-node.js
var AndNode = freeze({
is(node) {
return node.kind === "AndNode";
},
create(left, right) {
return freeze({
kind: "AndNode",
left,
right
});
}
});
// server/node_modules/kysely/dist/operation-node/or-node.js
var OrNode = freeze({
is(node) {
return node.kind === "OrNode";
},
create(left, right) {
return freeze({
kind: "OrNode",
left,
right
});
}
});
// server/node_modules/kysely/dist/operation-node/on-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/join-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/binary-operation-node.js
var BinaryOperationNode = freeze({
is(node) {
return node.kind === "BinaryOperationNode";
},
create(leftOperand, operator, rightOperand) {
return freeze({
kind: "BinaryOperationNode",
leftOperand,
operator,
rightOperand
});
}
});
// server/node_modules/kysely/dist/operation-node/operator-node.js
var 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
});
var COMPARISON_OPERATORS = Object.keys(COMPARISON_OPERATORS_DICTIONARY);
var ARITHMETIC_OPERATORS_DICTIONARY = freeze({
"+": true,
"-": true,
"*": true,
"/": true,
"%": true,
"^": true,
"&": true,
"|": true,
"#": true,
"<<": true,
">>": true
});
var ARITHMETIC_OPERATORS = Object.keys(ARITHMETIC_OPERATORS_DICTIONARY);
var JSON_OPERATORS_DICTIONARY = freeze({
"->": true,
"->>": true
});
var JSON_OPERATORS = Object.keys(JSON_OPERATORS_DICTIONARY);
var BINARY_OPERATORS_DICTIONARY = freeze({
...COMPARISON_OPERATORS_DICTIONARY,
...ARITHMETIC_OPERATORS_DICTIONARY,
"||": true
});
var BINARY_OPERATORS = Object.keys(BINARY_OPERATORS_DICTIONARY);
var UNARY_FILTER_OPERATORS_DICTIONARY = freeze({
exists: true,
"not exists": true
});
var UNARY_FILTER_OPERATORS = Object.keys(UNARY_FILTER_OPERATORS_DICTIONARY);
var UNARY_OPERATORS_DICTIONARY = freeze({
...UNARY_FILTER_OPERATORS_DICTIONARY,
"-": true,
not: true
});
var UNARY_OPERATORS = Object.keys(UNARY_OPERATORS_DICTIONARY);
var OPERATORS = [
...BINARY_OPERATORS,
...JSON_OPERATORS,
...UNARY_OPERATORS,
"between",
"between symmetric"
];
var 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];
}
// server/node_modules/kysely/dist/operation-node/column-node.js
var ColumnNode = freeze({
is(node) {
return node.kind === "ColumnNode";
},
create(column) {
return freeze({
kind: "ColumnNode",
column: IdentifierNode.create(column)
});
}
});
// server/node_modules/kysely/dist/operation-node/select-all-node.js
var SelectAllNode = freeze({
is(node) {
return node.kind === "SelectAllNode";
},
create() {
return freeze({
kind: "SelectAllNode"
});
}
});
// server/node_modules/kysely/dist/operation-node/reference-node.js
var 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()
});
}
});
// server/node_modules/kysely/dist/dynamic/dynamic-reference-builder.js
class DynamicReferenceBuilder {
#dynamicReference;
get dynamicReference() {
return this.#dynamicReference;
}
get refType() {
return;
}
constructor(reference) {
this.#dynamicReference = reference;
}
toOperationNode() {
return parseSimpleReferenceExpression(this.#dynamicReference);
}
}
function isDynamicReferenceBuilder(obj) {
return isObject(obj) && isOperationNodeSource(obj) && isString(obj.dynamicReference);
}
// server/node_modules/kysely/dist/operation-node/order-by-item-node.js
var OrderByItemNode = freeze({
is(node) {
return node.kind === "OrderByItemNode";
},
create(orderBy, direction) {
return freeze({
kind: "OrderByItemNode",
orderBy,
direction
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/raw-node.js
var 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);
}
});
// server/node_modules/kysely/dist/operation-node/collate-node.js
var CollateNode = freeze({
is(node) {
return node.kind === "CollateNode";
},
create(collation) {
return freeze({
kind: "CollateNode",
collation: IdentifierNode.create(collation)
});
}
});
// server/node_modules/kysely/dist/query-builder/order-by-item-builder.js
class OrderByItemBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
desc() {
return new OrderByItemBuilder({
node: OrderByItemNode.cloneWith(this.#props.node, {
direction: RawNode.createWithSql("desc")
})
});
}
asc() {
return new OrderByItemBuilder({
node: OrderByItemNode.cloneWith(this.#props.node, {
direction: RawNode.createWithSql("asc")
})
});
}
nullsLast() {
return new OrderByItemBuilder({
node: OrderByItemNode.cloneWith(this.#props.node, { nulls: "last" })
});
}
nullsFirst() {
return new OrderByItemBuilder({
node: OrderByItemNode.cloneWith(this.#props.node, { nulls: "first" })
});
}
collate(collation) {
return new OrderByItemBuilder({
node: OrderByItemNode.cloneWith(this.#props.node, {
collation: CollateNode.create(collation)
})
});
}
toOperationNode() {
return this.#props.node;
}
}
// server/node_modules/kysely/dist/util/log-once.js
var LOGGED_MESSAGES = new Set;
function logOnce(message) {
if (LOGGED_MESSAGES.has(message)) {
return;
}
LOGGED_MESSAGES.add(message);
console.log(message);
}
// server/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();
}
// server/node_modules/kysely/dist/operation-node/json-reference-node.js
var JSONReferenceNode = freeze({
is(node) {
return node.kind === "JSONReferenceNode";
},
create(reference, traversal) {
return freeze({
kind: "JSONReferenceNode",
reference,
traversal
});
},
cloneWithTraversal(node, traversal) {
return freeze({
...node,
traversal
});
}
});
// server/node_modules/kysely/dist/operation-node/json-operator-chain-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/json-path-node.js
var 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])
});
}
});
// server/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);
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);
return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
} else {
return parseStringReference(ref);
}
}
function parseColumnName(column) {
return ColumnNode.create(column);
}
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();
}
// server/node_modules/kysely/dist/operation-node/primitive-value-list-node.js
var PrimitiveValueListNode = freeze({
is(node) {
return node.kind === "PrimitiveValueListNode";
},
create(values) {
return freeze({
kind: "PrimitiveValueListNode",
values: freeze([...values])
});
}
});
// server/node_modules/kysely/dist/operation-node/value-list-node.js
var ValueListNode = freeze({
is(node) {
return node.kind === "ValueListNode";
},
create(values) {
return freeze({
kind: "ValueListNode",
values: freeze(values)
});
}
});
// server/node_modules/kysely/dist/operation-node/value-node.js
var ValueNode = freeze({
is(node) {
return node.kind === "ValueNode";
},
create(value) {
return freeze({
kind: "ValueNode",
value
});
},
createImmediate(value) {
return freeze({
kind: "ValueNode",
value,
immediate: true
});
}
});
// server/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);
}
// server/node_modules/kysely/dist/operation-node/parens-node.js
var ParensNode = freeze({
is(node) {
return node.kind === "ParensNode";
},
create(node) {
return freeze({
kind: "ParensNode",
node
});
}
});
// server/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;
}
// server/node_modules/kysely/dist/operation-node/order-by-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/partition-by-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/over-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/from-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/group-by-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/having-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/insert-query-node.js
var 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
});
}
});
// server/node_modules/kysely/dist/operation-node/list-node.js
var ListNode = freeze({
is(node) {
return node.kind === "ListNode";
},
create(items) {
return freeze({
kind: "ListNode",
items: freeze(items)
});
}
});
// server/node_modules/kysely/dist/operation-node/update-query-node.js
var 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
});
}
});
// server/node_modules/kysely/dist/operation-node/using-node.js
var 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])
});
}
});
// server/node_modules/kysely/dist/operation-node/delete-query-node.js
var DeleteQueryNode = freeze({
is(node) {
return node.kind === "DeleteQueryNode";
},
create(fromItems, withNode) {
return freeze({
kind: "DeleteQueryNode",
from: FromNode.create(fromItems),
...withNode && { with: withNode }
});
},
cloneWithOrderByItems: (node, items) => QueryNode.cloneWithOrderByItems(node, items),
cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
cloneWithLimit(deleteNode, limit) {
return freeze({
...deleteNode,
limit
});
},
cloneWithoutLimit(deleteNode) {
return freeze({
...deleteNode,
limit: undefined
});
},
cloneWithUsing(deleteNode, tables) {
return freeze({
...deleteNode,
using: deleteNode.using !== undefined ? UsingNode.cloneWithTables(deleteNode.using, tables) : UsingNode.create(tables)
});
}
});
// server/node_modules/kysely/dist/operation-node/where-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/returning-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/explain-node.js
var ExplainNode = freeze({
is(node) {
return node.kind === "ExplainNode";
},
create(format, options) {
return freeze({
kind: "ExplainNode",
format,
options
});
}
});
// server/node_modules/kysely/dist/operation-node/when-node.js
var WhenNode = freeze({
is(node) {
return node.kind === "WhenNode";
},
create(condition) {
return freeze({
kind: "WhenNode",
condition
});
},
cloneWithResult(whenNode, result) {
return freeze({
...whenNode,
result
});
}
});
// server/node_modules/kysely/dist/operation-node/merge-query-node.js
var 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
});
}
});
// server/node_modules/kysely/dist/operation-node/output-node.js
var 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)
});
}
});
// server/node_modules/kysely/dist/operation-node/query-node.js
var 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: undefined
});
},
cloneWithoutWhere(node) {
return freeze({
...node,
where: undefined
});
},
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: undefined
});
}
});
// server/node_modules/kysely/dist/operation-node/select-query-node.js
var 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])
});
},
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: undefined
});
},
cloneWithoutOffset(select) {
return freeze({
...select,
offset: undefined
});
},
cloneWithoutOrderBy: (node) => QueryNode.cloneWithoutOrderBy(node),
cloneWithoutGroupBy(select) {
return freeze({
...select,
groupBy: undefined
});
}
});
// server/node_modules/kysely/dist/query-builder/join-builder.js
class JoinBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
on(...args) {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseValueBinaryOperationOrExpression(args))
});
}
onRef(lhs, op, rhs) {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
onTrue() {
return new JoinBuilder({
...this.#props,
joinNode: JoinNode.cloneWithOn(this.#props.joinNode, RawNode.createWithSql("true"))
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.joinNode;
}
}
// server/node_modules/kysely/dist/operation-node/partition-by-item-node.js
var PartitionByItemNode = freeze({
is(node) {
return node.kind === "PartitionByItemNode";
},
create(partitionBy) {
return freeze({
kind: "PartitionByItemNode",
partitionBy
});
}
});
// server/node_modules/kysely/dist/parser/partition-by-parser.js
function parsePartitionBy(partitionBy) {
return parseReferenceExpressionOrList(partitionBy).map(PartitionByItemNode.create);
}
// server/node_modules/kysely/dist/query-builder/over-builder.js
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))
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.overNode;
}
}
// server/node_modules/kysely/dist/operation-node/selection-node.js
var 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)
});
}
});
// server/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)}`);
}
// server/node_modules/kysely/dist/operation-node/values-node.js
var ValuesNode = freeze({
is(node) {
return node.kind === "ValuesNode";
},
create(values) {
return freeze({
kind: "ValuesNode",
values: freeze(values)
});
}
});
// server/node_modules/kysely/dist/operation-node/default-insert-value-node.js
var DefaultInsertValueNode = freeze({
is(node) {
return node.kind === "DefaultInsertValueNode";
},
create() {
return freeze({
kind: "DefaultInsertValueNode"
});
}
});
// server/node_modules/kysely/dist/parser/insert-values-parser.js
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);
}
// server/node_modules/kysely/dist/operation-node/column-update-node.js
var ColumnUpdateNode = freeze({
is(node) {
return node.kind === "ColumnUpdateNode";
},
create(column, value) {
return freeze({
kind: "ColumnUpdateNode",
column,
value
});
}
});
// server/node_modules/kysely/dist/parser/update-set-parser.js
function parseUpdate(...args) {
if (args.length === 2) {
return [
ColumnUpdateNode.create(parseReferenceExpression(args[0]), parseValueExpression(args[1]))
];
}
return parseUpdateObjectExpression(args[0]);
}
function parseUpdateObjectExpression(update) {
const updateObj = isFunction(update) ? update(expressionBuilder()) : update;
return Object.entries(updateObj).filter(([_, value]) => value !== undefined).map(([key, value]) => {
return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));
});
}
// server/node_modules/kysely/dist/operation-node/on-duplicate-key-node.js
var OnDuplicateKeyNode = freeze({
is(node) {
return node.kind === "OnDuplicateKeyNode";
},
create(updates) {
return freeze({
kind: "OnDuplicateKeyNode",
updates
});
}
});
// server/node_modules/kysely/dist/query-builder/insert-result.js
class InsertResult {
insertId;
numInsertedOrUpdatedRows;
constructor(insertId, numInsertedOrUpdatedRows) {
this.insertId = insertId;
this.numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
}
}
// server/node_modules/kysely/dist/query-builder/no-result-error.js
class NoResultError extends Error {
node;
constructor(node) {
super("no result");
this.node = node;
}
}
function isNoResultErrorConstructor(fn) {
return Object.prototype.hasOwnProperty.call(fn, "prototype");
}
// server/node_modules/kysely/dist/operation-node/on-conflict-node.js
var OnConflictNode = freeze({
is(node) {
return node.kind === "OnConflictNode";
},
create() {
return freeze({
kind: "OnConflictNode"
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
},
cloneWithIndexWhere(node, operation) {
return freeze({
...node,
indexWhere: node.indexWhere ? WhereNode.cloneWithOperation(node.indexWhere, "And", operation) : WhereNode.create(operation)
});
},
cloneWithIndexOrWhere(node, operation) {
return freeze({
...node,
indexWhere: node.indexWhere ? WhereNode.cloneWithOperation(node.indexWhere, "Or", operation) : WhereNode.create(operation)
});
},
cloneWithUpdateWhere(node, operation) {
return freeze({
...node,
updateWhere: node.updateWhere ? WhereNode.cloneWithOperation(node.updateWhere, "And", operation) : WhereNode.create(operation)
});
},
cloneWithUpdateOrWhere(node, operation) {
return freeze({
...node,
updateWhere: node.updateWhere ? WhereNode.cloneWithOperation(node.updateWhere, "Or", operation) : WhereNode.create(operation)
});
},
cloneWithoutIndexWhere(node) {
return freeze({
...node,
indexWhere: undefined
});
},
cloneWithoutUpdateWhere(node) {
return freeze({
...node,
updateWhere: undefined
});
}
});
// server/node_modules/kysely/dist/query-builder/on-conflict-builder.js
class OnConflictBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
column(column) {
const columnNode = ColumnNode.create(column);
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
columns: this.#props.onConflictNode.columns ? freeze([...this.#props.onConflictNode.columns, columnNode]) : freeze([columnNode])
})
});
}
columns(columns) {
const columnNodes = columns.map(ColumnNode.create);
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
columns: this.#props.onConflictNode.columns ? freeze([...this.#props.onConflictNode.columns, ...columnNodes]) : freeze(columnNodes)
})
});
}
constraint(constraintName) {
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
constraint: IdentifierNode.create(constraintName)
})
});
}
expression(expression) {
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
indexExpression: expression.toOperationNode()
})
});
}
where(...args) {
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseValueBinaryOperationOrExpression(args))
});
}
whereRef(lhs, op, rhs) {
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
clearWhere() {
return new OnConflictBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithoutIndexWhere(this.#props.onConflictNode)
});
}
doNothing() {
return new OnConflictDoNothingBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
doNothing: true
})
});
}
doUpdateSet(update) {
return new OnConflictUpdateBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
updates: parseUpdateObjectExpression(update)
})
});
}
$call(func) {
return func(this);
}
}
class OnConflictDoNothingBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
toOperationNode() {
return this.#props.onConflictNode;
}
}
class OnConflictUpdateBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
where(...args) {
return new OnConflictUpdateBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseValueBinaryOperationOrExpression(args))
});
}
whereRef(lhs, op, rhs) {
return new OnConflictUpdateBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
clearWhere() {
return new OnConflictUpdateBuilder({
...this.#props,
onConflictNode: OnConflictNode.cloneWithoutUpdateWhere(this.#props.onConflictNode)
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.onConflictNode;
}
}
// server/node_modules/kysely/dist/operation-node/top-node.js
var TopNode = freeze({
is(node) {
return node.kind === "TopNode";
},
create(expression, modifiers) {
return freeze({
kind: "TopNode",
expression,
modifiers
});
}
});
// server/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";
}
// server/node_modules/kysely/dist/operation-node/or-action-node.js
var OrActionNode = freeze({
is(node) {
return node.kind === "OrActionNode";
},
create(action) {
return freeze({
kind: "OrActionNode",
action
});
}
});
// server/node_modules/kysely/dist/query-builder/insert-query-builder.js
class InsertQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
values(insert) {
const [columns, values] = parseInsertExpression(insert);
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
columns,
values
})
});
}
columns(columns) {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
columns: freeze(columns.map(ColumnNode.create))
})
});
}
expression(expression) {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
values: parseExpression(expression)
})
});
}
defaultValues() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
defaultValues: true
})
});
}
modifyEnd(modifier) {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
});
}
ignore() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("ignore")
})
});
}
orIgnore() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("ignore")
})
});
}
orAbort() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("abort")
})
});
}
orFail() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("fail")
})
});
}
orReplace() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("replace")
})
});
}
orRollback() {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
orAction: OrActionNode.create("rollback")
})
});
}
top(expression, modifiers) {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
onConflict(callback) {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
onConflict: callback(new OnConflictBuilder({
onConflictNode: OnConflictNode.create()
})).toOperationNode()
})
});
}
onDuplicateKeyUpdate(update) {
return new InsertQueryBuilder({
...this.#props,
queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObjectExpression(update))
})
});
}
returning(selection) {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection))
});
}
returningAll() {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll())
});
}
output(args) {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
});
}
outputAll(table) {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
});
}
clearReturning() {
return new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode)
});
}
$call(func) {
return func(this);
}
$if(condition, func) {
if (condition) {
return func(this);
}
return new InsertQueryBuilder({
...this.#props
});
}
$castTo() {
return new InsertQueryBuilder(this.#props);
}
$narrowType() {
return new InsertQueryBuilder(this.#props);
}
$assertType() {
return new InsertQueryBuilder(this.#props);
}
withPlugin(plugin) {
return new InsertQueryBuilder({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
const compiledQuery = this.compile();
const result = await this.#props.executor.executeQuery(compiledQuery, options);
const { adapter } = this.#props.executor;
const query = compiledQuery.query;
if (query.returning && adapter.supportsReturning || query.output && adapter.supportsOutput) {
return result.rows;
}
return [
new InsertResult(result.insertId, result.numAffectedRows ?? BigInt(0))
];
}
async executeTakeFirst(options) {
const [result] = await this.execute(options);
return result;
}
async executeTakeFirstOrThrow(errorConstructorOrOptions) {
if (typeof errorConstructorOrOptions === "function") {
errorConstructorOrOptions = {
errorConstructor: errorConstructorOrOptions
};
}
const result = await this.executeTakeFirst(errorConstructorOrOptions);
if (result === undefined) {
const errorConstructor = errorConstructorOrOptions?.errorConstructor ?? NoResultError;
const error = isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
throw error;
}
return result;
}
async* stream(chunkSizeOrOptions) {
if (typeof chunkSizeOrOptions !== "object") {
chunkSizeOrOptions = {
chunkSize: chunkSizeOrOptions
};
}
const compiledQuery = this.compile();
const stream = this.#props.executor.stream(compiledQuery, chunkSizeOrOptions.chunkSize ?? 100, chunkSizeOrOptions);
for await (const item of stream) {
yield* item.rows;
}
}
async explain(format, options) {
const builder = new InsertQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options)
});
return await builder.execute();
}
}
// server/node_modules/kysely/dist/query-builder/delete-result.js
class DeleteResult {
numDeletedRows;
constructor(numDeletedRows) {
this.numDeletedRows = numDeletedRows;
}
}
// server/node_modules/kysely/dist/operation-node/limit-node.js
var LimitNode = freeze({
is(node) {
return node.kind === "LimitNode";
},
create(limit) {
return freeze({
kind: "LimitNode",
limit
});
}
});
// server/node_modules/kysely/dist/query-builder/delete-query-builder.js
var _a;
class DeleteQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
where(...args) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args))
});
}
whereRef(lhs, op, rhs) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
clearWhere() {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode)
});
}
top(expression, modifiers) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
using(tables) {
return new _a({
...this.#props,
queryNode: DeleteQueryNode.cloneWithUsing(this.#props.queryNode, parseTableExpressionOrList(tables))
});
}
innerJoin(...args) {
return this.#join("InnerJoin", args);
}
leftJoin(...args) {
return this.#join("LeftJoin", args);
}
rightJoin(...args) {
return this.#join("RightJoin", args);
}
fullJoin(...args) {
return this.#join("FullJoin", args);
}
#join(joinType, args) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args))
});
}
returning(selection) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection))
});
}
returningAll(table) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
});
}
output(args) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
});
}
outputAll(table) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
});
}
clearReturning() {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode)
});
}
clearLimit() {
return new _a({
...this.#props,
queryNode: DeleteQueryNode.cloneWithoutLimit(this.#props.queryNode)
});
}
orderBy(...args) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args))
});
}
clearOrderBy() {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode)
});
}
limit(limit) {
return new _a({
...this.#props,
queryNode: DeleteQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit)))
});
}
modifyEnd(modifier) {
return new _a({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
});
}
$call(func) {
return func(this);
}
$if(condition, func) {
if (condition) {
return func(this);
}
return new _a({
...this.#props
});
}
$castTo() {
return new _a(this.#props);
}
$narrowType() {
return new _a(this.#props);
}
$assertType() {
return new _a(this.#props);
}
withPlugin(plugin) {
return new _a({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
const compiledQuery = this.compile();
const result = await this.#props.executor.executeQuery(compiledQuery, options);
const { adapter } = this.#props.executor;
const query = compiledQuery.query;
if (query.returning && adapter.supportsReturning || query.output && adapter.supportsOutput) {
return result.rows;
}
return [new DeleteResult(result.numAffectedRows ?? BigInt(0))];
}
async executeTakeFirst(options) {
const [result] = await this.execute(options);
return result;
}
async executeTakeFirstOrThrow(errorConstructorOrOptions) {
if (typeof errorConstructorOrOptions === "function") {
errorConstructorOrOptions = {
errorConstructor: errorConstructorOrOptions
};
}
const result = await this.executeTakeFirst(errorConstructorOrOptions);
if (result === undefined) {
const errorConstructor = errorConstructorOrOptions?.errorConstructor ?? NoResultError;
const error = isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
throw error;
}
return result;
}
async* stream(chunkSizeOrOptions) {
if (typeof chunkSizeOrOptions !== "object") {
chunkSizeOrOptions = {
chunkSize: chunkSizeOrOptions
};
}
const compiledQuery = this.compile();
const stream = this.#props.executor.stream(compiledQuery, chunkSizeOrOptions.chunkSize ?? 100, chunkSizeOrOptions);
for await (const item of stream) {
yield* item.rows;
}
}
async explain(format, options) {
const builder = new _a({
...this.#props,
queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options)
});
return await builder.execute();
}
}
_a = DeleteQueryBuilder;
// server/node_modules/kysely/dist/query-builder/update-result.js
class UpdateResult {
numUpdatedRows;
numChangedRows;
constructor(numUpdatedRows, numChangedRows) {
this.numUpdatedRows = numUpdatedRows;
this.numChangedRows = numChangedRows;
}
}
// server/node_modules/kysely/dist/query-builder/update-query-builder.js
var _a2;
class UpdateQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
where(...args) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args))
});
}
whereRef(lhs, op, rhs) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
clearWhere() {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode)
});
}
top(expression, modifiers) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
from(from) {
return new _a2({
...this.#props,
queryNode: UpdateQueryNode.cloneWithFromItems(this.#props.queryNode, parseTableExpressionOrList(from))
});
}
innerJoin(...args) {
return this.#join("InnerJoin", args);
}
leftJoin(...args) {
return this.#join("LeftJoin", args);
}
rightJoin(...args) {
return this.#join("RightJoin", args);
}
fullJoin(...args) {
return this.#join("FullJoin", args);
}
#join(joinType, args) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args))
});
}
orderBy(...args) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args))
});
}
clearOrderBy() {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode)
});
}
limit(limit) {
return new _a2({
...this.#props,
queryNode: UpdateQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit)))
});
}
set(...args) {
return new _a2({
...this.#props,
queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdate(...args))
});
}
returning(selection) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection))
});
}
returningAll(table) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
});
}
output(args) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
});
}
outputAll(table) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
});
}
modifyEnd(modifier) {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
});
}
clearReturning() {
return new _a2({
...this.#props,
queryNode: QueryNode.cloneWithoutReturning(this.#props.queryNode)
});
}
$call(func) {
return func(this);
}
$if(condition, func) {
if (condition) {
return func(this);
}
return new _a2({
...this.#props
});
}
$castTo() {
return new _a2(this.#props);
}
$narrowType() {
return new _a2(this.#props);
}
$assertType() {
return new _a2(this.#props);
}
withPlugin(plugin) {
return new _a2({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
const compiledQuery = this.compile();
const result = await this.#props.executor.executeQuery(compiledQuery, options);
const { adapter } = this.#props.executor;
const query = compiledQuery.query;
if (query.returning && adapter.supportsReturning || query.output && adapter.supportsOutput) {
return result.rows;
}
return [
new UpdateResult(result.numAffectedRows ?? BigInt(0), result.numChangedRows)
];
}
async executeTakeFirst(options) {
const [result] = await this.execute(options);
return result;
}
async executeTakeFirstOrThrow(errorConstructorOrOptions) {
if (typeof errorConstructorOrOptions === "function") {
errorConstructorOrOptions = {
errorConstructor: errorConstructorOrOptions
};
}
const result = await this.executeTakeFirst(errorConstructorOrOptions);
if (result === undefined) {
const errorConstructor = errorConstructorOrOptions?.errorConstructor ?? NoResultError;
const error = isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
throw error;
}
return result;
}
async* stream(chunkSizeOrOptions) {
if (typeof chunkSizeOrOptions !== "object") {
chunkSizeOrOptions = {
chunkSize: chunkSizeOrOptions
};
}
const compiledQuery = this.compile();
const stream = this.#props.executor.stream(compiledQuery, chunkSizeOrOptions.chunkSize ?? 100, chunkSizeOrOptions);
for await (const item of stream) {
yield* item.rows;
}
}
async explain(format, options) {
const builder = new _a2({
...this.#props,
queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options)
});
return await builder.execute();
}
}
_a2 = UpdateQueryBuilder;
// server/node_modules/kysely/dist/operation-node/common-table-expression-name-node.js
var CommonTableExpressionNameNode = freeze({
is(node) {
return node.kind === "CommonTableExpressionNameNode";
},
create(tableName, columnNames) {
return freeze({
kind: "CommonTableExpressionNameNode",
table: TableNode.create(tableName),
columns: columnNames ? freeze(columnNames.map(ColumnNode.create)) : undefined
});
}
});
// server/node_modules/kysely/dist/operation-node/common-table-expression-node.js
var CommonTableExpressionNode = freeze({
is(node) {
return node.kind === "CommonTableExpressionNode";
},
create(name, expression) {
return freeze({
kind: "CommonTableExpressionNode",
name,
expression
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/query-builder/cte-builder.js
class CTEBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
materialized() {
return new CTEBuilder({
...this.#props,
node: CommonTableExpressionNode.cloneWith(this.#props.node, {
materialized: true
})
});
}
notMaterialized() {
return new CTEBuilder({
...this.#props,
node: CommonTableExpressionNode.cloneWith(this.#props.node, {
materialized: false
})
});
}
toOperationNode() {
return this.#props.node;
}
}
// server/node_modules/kysely/dist/parser/with-parser.js
function parseCommonTableExpression(nameOrBuilderCallback, expression) {
const expressionNode = isOperationNodeSource(expression) ? expression.toOperationNode() : expression(createQueryCreator()).toOperationNode();
if (isFunction(nameOrBuilderCallback)) {
return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
}
return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
}
function cteBuilderFactory(expressionNode) {
return (name) => {
return new CTEBuilder({
node: CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode)
});
};
}
function parseCommonTableExpressionName(name) {
if (name.includes("(")) {
const parts = name.split(/[\(\)]/);
const table = parts[0];
const columns = parts[1].split(",").map((it) => it.trim());
return CommonTableExpressionNameNode.create(table, columns);
} else {
return CommonTableExpressionNameNode.create(name);
}
}
// server/node_modules/kysely/dist/operation-node/with-node.js
var WithNode = freeze({
is(node) {
return node.kind === "WithNode";
},
create(expression, params) {
return freeze({
kind: "WithNode",
expressions: freeze([expression]),
...params
});
},
cloneWithExpression(withNode, expression) {
return freeze({
...withNode,
expressions: freeze([...withNode.expressions, expression])
});
}
});
// server/node_modules/kysely/dist/util/random-string.js
var 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)];
}
// server/node_modules/kysely/dist/util/query-id.js
function createQueryId() {
return new LazyQueryId;
}
class LazyQueryId {
#queryId;
get queryId() {
if (this.#queryId === undefined) {
this.#queryId = randomString(8);
}
return this.#queryId;
}
}
// server/node_modules/kysely/dist/operation-node/operation-node-transformer.js
class OperationNodeTransformer {
nodeStack = [];
#transformers = freeze({
AliasNode: this.transformAlias.bind(this),
ColumnNode: this.transformColumn.bind(this),
IdentifierNode: this.transformIdentifier.bind(this),
SchemableIdentifierNode: this.transformSchemableIdentifier.bind(this),
RawNode: this.transformRaw.bind(this),
ReferenceNode: this.transformReference.bind(this),
SelectQueryNode: this.transformSelectQuery.bind(this),
SelectionNode: this.transformSelection.bind(this),
TableNode: this.transformTable.bind(this),
FromNode: this.transformFrom.bind(this),
SelectAllNode: this.transformSelectAll.bind(this),
AndNode: this.transformAnd.bind(this),
OrNode: this.transformOr.bind(this),
ValueNode: this.transformValue.bind(this),
ValueListNode: this.transformValueList.bind(this),
PrimitiveValueListNode: this.transformPrimitiveValueList.bind(this),
ParensNode: this.transformParens.bind(this),
JoinNode: this.transformJoin.bind(this),
OperatorNode: this.transformOperator.bind(this),
WhereNode: this.transformWhere.bind(this),
InsertQueryNode: this.transformInsertQuery.bind(this),
DeleteQueryNode: this.transformDeleteQuery.bind(this),
ReturningNode: this.transformReturning.bind(this),
CreateTableNode: this.transformCreateTable.bind(this),
AddColumnNode: this.transformAddColumn.bind(this),
ColumnDefinitionNode: this.transformColumnDefinition.bind(this),
DropTableNode: this.transformDropTable.bind(this),
DataTypeNode: this.transformDataType.bind(this),
OrderByNode: this.transformOrderBy.bind(this),
OrderByItemNode: this.transformOrderByItem.bind(this),
GroupByNode: this.transformGroupBy.bind(this),
GroupByItemNode: this.transformGroupByItem.bind(this),
UpdateQueryNode: this.transformUpdateQuery.bind(this),
ColumnUpdateNode: this.transformColumnUpdate.bind(this),
LimitNode: this.transformLimit.bind(this),
OffsetNode: this.transformOffset.bind(this),
OnConflictNode: this.transformOnConflict.bind(this),
OnDuplicateKeyNode: this.transformOnDuplicateKey.bind(this),
CreateIndexNode: this.transformCreateIndex.bind(this),
DropIndexNode: this.transformDropIndex.bind(this),
ListNode: this.transformList.bind(this),
PrimaryKeyConstraintNode: this.transformPrimaryKeyConstraint.bind(this),
UniqueConstraintNode: this.transformUniqueConstraint.bind(this),
ReferencesNode: this.transformReferences.bind(this),
CheckConstraintNode: this.transformCheckConstraint.bind(this),
WithNode: this.transformWith.bind(this),
CommonTableExpressionNode: this.transformCommonTableExpression.bind(this),
CommonTableExpressionNameNode: this.transformCommonTableExpressionName.bind(this),
HavingNode: this.transformHaving.bind(this),
CreateSchemaNode: this.transformCreateSchema.bind(this),
DropSchemaNode: this.transformDropSchema.bind(this),
AlterTableNode: this.transformAlterTable.bind(this),
DropColumnNode: this.transformDropColumn.bind(this),
RenameColumnNode: this.transformRenameColumn.bind(this),
AlterColumnNode: this.transformAlterColumn.bind(this),
ModifyColumnNode: this.transformModifyColumn.bind(this),
AddConstraintNode: this.transformAddConstraint.bind(this),
DropConstraintNode: this.transformDropConstraint.bind(this),
RenameConstraintNode: this.transformRenameConstraint.bind(this),
ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
CreateViewNode: this.transformCreateView.bind(this),
RefreshMaterializedViewNode: this.transformRefreshMaterializedView.bind(this),
DropViewNode: this.transformDropView.bind(this),
GeneratedNode: this.transformGenerated.bind(this),
DefaultValueNode: this.transformDefaultValue.bind(this),
OnNode: this.transformOn.bind(this),
ValuesNode: this.transformValues.bind(this),
SelectModifierNode: this.transformSelectModifier.bind(this),
CreateTypeNode: this.transformCreateType.bind(this),
DropTypeNode: this.transformDropType.bind(this),
ExplainNode: this.transformExplain.bind(this),
DefaultInsertValueNode: this.transformDefaultInsertValue.bind(this),
AggregateFunctionNode: this.transformAggregateFunction.bind(this),
OverNode: this.transformOver.bind(this),
PartitionByNode: this.transformPartitionBy.bind(this),
PartitionByItemNode: this.transformPartitionByItem.bind(this),
SetOperationNode: this.transformSetOperation.bind(this),
BinaryOperationNode: this.transformBinaryOperation.bind(this),
UnaryOperationNode: this.transformUnaryOperation.bind(this),
UsingNode: this.transformUsing.bind(this),
FunctionNode: this.transformFunction.bind(this),
CaseNode: this.transformCase.bind(this),
WhenNode: this.transformWhen.bind(this),
JSONReferenceNode: this.transformJSONReference.bind(this),
JSONPathNode: this.transformJSONPath.bind(this),
JSONPathLegNode: this.transformJSONPathLeg.bind(this),
JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
TupleNode: this.transformTuple.bind(this),
MergeQueryNode: this.transformMergeQuery.bind(this),
MatchedNode: this.transformMatched.bind(this),
AddIndexNode: this.transformAddIndex.bind(this),
CastNode: this.transformCast.bind(this),
FetchNode: this.transformFetch.bind(this),
TopNode: this.transformTop.bind(this),
OutputNode: this.transformOutput.bind(this),
OrActionNode: this.transformOrAction.bind(this),
CollateNode: this.transformCollate.bind(this),
AlterTypeNode: this.transformAlterType.bind(this),
AddValueNode: this.transformAddValue.bind(this),
RenameValueNode: this.transformRenameValue.bind(this)
});
transformNode(node, queryId) {
if (!node) {
return node;
}
this.nodeStack.push(node);
const out = this.transformNodeImpl(node, queryId);
this.nodeStack.pop();
return freeze(out);
}
transformNodeImpl(node, queryId) {
return this.#transformers[node.kind](node, queryId);
}
transformNodeList(list, queryId) {
if (!list) {
return list;
}
return freeze(list.map((node) => this.transformNode(node, queryId)));
}
transformSelectQuery(node, queryId) {
return {
kind: "SelectQueryNode",
from: this.transformNode(node.from, queryId),
selections: this.transformNodeList(node.selections, queryId),
distinctOn: this.transformNodeList(node.distinctOn, queryId),
joins: this.transformNodeList(node.joins, queryId),
groupBy: this.transformNode(node.groupBy, queryId),
orderBy: this.transformNode(node.orderBy, queryId),
where: this.transformNode(node.where, queryId),
frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
limit: this.transformNode(node.limit, queryId),
offset: this.transformNode(node.offset, queryId),
with: this.transformNode(node.with, queryId),
having: this.transformNode(node.having, queryId),
explain: this.transformNode(node.explain, queryId),
setOperations: this.transformNodeList(node.setOperations, queryId),
fetch: this.transformNode(node.fetch, queryId),
top: this.transformNode(node.top, queryId)
};
}
transformSelection(node, queryId) {
return {
kind: "SelectionNode",
selection: this.transformNode(node.selection, queryId)
};
}
transformColumn(node, queryId) {
return {
kind: "ColumnNode",
column: this.transformNode(node.column, queryId)
};
}
transformAlias(node, queryId) {
return {
kind: "AliasNode",
node: this.transformNode(node.node, queryId),
alias: this.transformNode(node.alias, queryId)
};
}
transformTable(node, queryId) {
return {
kind: "TableNode",
table: this.transformNode(node.table, queryId)
};
}
transformFrom(node, queryId) {
return {
kind: "FromNode",
froms: this.transformNodeList(node.froms, queryId)
};
}
transformReference(node, queryId) {
return {
kind: "ReferenceNode",
column: this.transformNode(node.column, queryId),
table: this.transformNode(node.table, queryId)
};
}
transformAnd(node, queryId) {
return {
kind: "AndNode",
left: this.transformNode(node.left, queryId),
right: this.transformNode(node.right, queryId)
};
}
transformOr(node, queryId) {
return {
kind: "OrNode",
left: this.transformNode(node.left, queryId),
right: this.transformNode(node.right, queryId)
};
}
transformValueList(node, queryId) {
return {
kind: "ValueListNode",
values: this.transformNodeList(node.values, queryId)
};
}
transformParens(node, queryId) {
return {
kind: "ParensNode",
node: this.transformNode(node.node, queryId)
};
}
transformJoin(node, queryId) {
return {
kind: "JoinNode",
joinType: node.joinType,
table: this.transformNode(node.table, queryId),
on: this.transformNode(node.on, queryId)
};
}
transformRaw(node, queryId) {
return {
kind: "RawNode",
sqlFragments: freeze([...node.sqlFragments]),
parameters: this.transformNodeList(node.parameters, queryId)
};
}
transformWhere(node, queryId) {
return {
kind: "WhereNode",
where: this.transformNode(node.where, queryId)
};
}
transformInsertQuery(node, queryId) {
return {
kind: "InsertQueryNode",
into: this.transformNode(node.into, queryId),
columns: this.transformNodeList(node.columns, queryId),
values: this.transformNode(node.values, queryId),
returning: this.transformNode(node.returning, queryId),
onConflict: this.transformNode(node.onConflict, queryId),
onDuplicateKey: this.transformNode(node.onDuplicateKey, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
with: this.transformNode(node.with, queryId),
orAction: this.transformNode(node.orAction, queryId),
replace: node.replace,
explain: this.transformNode(node.explain, queryId),
defaultValues: node.defaultValues,
top: this.transformNode(node.top, queryId),
output: this.transformNode(node.output, queryId)
};
}
transformValues(node, queryId) {
return {
kind: "ValuesNode",
values: this.transformNodeList(node.values, queryId)
};
}
transformDeleteQuery(node, queryId) {
return {
kind: "DeleteQueryNode",
from: this.transformNode(node.from, queryId),
using: this.transformNode(node.using, queryId),
joins: this.transformNodeList(node.joins, queryId),
where: this.transformNode(node.where, queryId),
returning: this.transformNode(node.returning, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
with: this.transformNode(node.with, queryId),
orderBy: this.transformNode(node.orderBy, queryId),
limit: this.transformNode(node.limit, queryId),
explain: this.transformNode(node.explain, queryId),
top: this.transformNode(node.top, queryId),
output: this.transformNode(node.output, queryId)
};
}
transformReturning(node, queryId) {
return {
kind: "ReturningNode",
selections: this.transformNodeList(node.selections, queryId)
};
}
transformCreateTable(node, queryId) {
return {
kind: "CreateTableNode",
table: this.transformNode(node.table, queryId),
columns: this.transformNodeList(node.columns, queryId),
constraints: this.transformNodeList(node.constraints, queryId),
indexes: this.transformNodeList(node.indexes, queryId),
temporary: node.temporary,
ifNotExists: node.ifNotExists,
onCommit: node.onCommit,
frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
selectQuery: this.transformNode(node.selectQuery, queryId)
};
}
transformColumnDefinition(node, queryId) {
return {
kind: "ColumnDefinitionNode",
column: this.transformNode(node.column, queryId),
dataType: this.transformNode(node.dataType, queryId),
references: this.transformNode(node.references, queryId),
primaryKey: node.primaryKey,
autoIncrement: node.autoIncrement,
unique: node.unique,
notNull: node.notNull,
unsigned: node.unsigned,
defaultTo: this.transformNode(node.defaultTo, queryId),
check: this.transformNode(node.check, queryId),
generated: this.transformNode(node.generated, queryId),
frontModifiers: this.transformNodeList(node.frontModifiers, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
nullsNotDistinct: node.nullsNotDistinct,
identity: node.identity,
ifNotExists: node.ifNotExists
};
}
transformAddColumn(node, queryId) {
return {
kind: "AddColumnNode",
column: this.transformNode(node.column, queryId)
};
}
transformDropTable(node, queryId) {
return {
kind: "DropTableNode",
table: this.transformNode(node.table, queryId),
ifExists: node.ifExists,
cascade: node.cascade,
temporary: node.temporary
};
}
transformOrderBy(node, queryId) {
return {
kind: "OrderByNode",
items: this.transformNodeList(node.items, queryId)
};
}
transformOrderByItem(node, queryId) {
return {
kind: "OrderByItemNode",
orderBy: this.transformNode(node.orderBy, queryId),
direction: this.transformNode(node.direction, queryId),
collation: this.transformNode(node.collation, queryId),
nulls: node.nulls
};
}
transformGroupBy(node, queryId) {
return {
kind: "GroupByNode",
items: this.transformNodeList(node.items, queryId)
};
}
transformGroupByItem(node, queryId) {
return {
kind: "GroupByItemNode",
groupBy: this.transformNode(node.groupBy, queryId)
};
}
transformUpdateQuery(node, queryId) {
return {
kind: "UpdateQueryNode",
table: this.transformNode(node.table, queryId),
from: this.transformNode(node.from, queryId),
joins: this.transformNodeList(node.joins, queryId),
where: this.transformNode(node.where, queryId),
updates: this.transformNodeList(node.updates, queryId),
returning: this.transformNode(node.returning, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
with: this.transformNode(node.with, queryId),
explain: this.transformNode(node.explain, queryId),
limit: this.transformNode(node.limit, queryId),
top: this.transformNode(node.top, queryId),
output: this.transformNode(node.output, queryId),
orderBy: this.transformNode(node.orderBy, queryId)
};
}
transformColumnUpdate(node, queryId) {
return {
kind: "ColumnUpdateNode",
column: this.transformNode(node.column, queryId),
value: this.transformNode(node.value, queryId)
};
}
transformLimit(node, queryId) {
return {
kind: "LimitNode",
limit: this.transformNode(node.limit, queryId)
};
}
transformOffset(node, queryId) {
return {
kind: "OffsetNode",
offset: this.transformNode(node.offset, queryId)
};
}
transformOnConflict(node, queryId) {
return {
kind: "OnConflictNode",
columns: this.transformNodeList(node.columns, queryId),
constraint: this.transformNode(node.constraint, queryId),
indexExpression: this.transformNode(node.indexExpression, queryId),
indexWhere: this.transformNode(node.indexWhere, queryId),
updates: this.transformNodeList(node.updates, queryId),
updateWhere: this.transformNode(node.updateWhere, queryId),
doNothing: node.doNothing
};
}
transformOnDuplicateKey(node, queryId) {
return {
kind: "OnDuplicateKeyNode",
updates: this.transformNodeList(node.updates, queryId)
};
}
transformCreateIndex(node, queryId) {
return {
kind: "CreateIndexNode",
name: this.transformNode(node.name, queryId),
table: this.transformNode(node.table, queryId),
columns: this.transformNodeList(node.columns, queryId),
unique: node.unique,
using: this.transformNode(node.using, queryId),
ifNotExists: node.ifNotExists,
where: this.transformNode(node.where, queryId),
nullsNotDistinct: node.nullsNotDistinct
};
}
transformList(node, queryId) {
return {
kind: "ListNode",
items: this.transformNodeList(node.items, queryId)
};
}
transformDropIndex(node, queryId) {
return {
kind: "DropIndexNode",
name: this.transformNode(node.name, queryId),
table: this.transformNode(node.table, queryId),
ifExists: node.ifExists,
cascade: node.cascade
};
}
transformPrimaryKeyConstraint(node, queryId) {
return {
kind: "PrimaryKeyConstraintNode",
columns: this.transformNodeList(node.columns, queryId),
name: this.transformNode(node.name, queryId),
deferrable: node.deferrable,
initiallyDeferred: node.initiallyDeferred
};
}
transformUniqueConstraint(node, queryId) {
return {
kind: "UniqueConstraintNode",
columns: this.transformNodeList(node.columns, queryId),
name: this.transformNode(node.name, queryId),
nullsNotDistinct: node.nullsNotDistinct,
deferrable: node.deferrable,
initiallyDeferred: node.initiallyDeferred
};
}
transformForeignKeyConstraint(node, queryId) {
return {
kind: "ForeignKeyConstraintNode",
columns: this.transformNodeList(node.columns, queryId),
references: this.transformNode(node.references, queryId),
name: this.transformNode(node.name, queryId),
onDelete: node.onDelete,
onUpdate: node.onUpdate,
deferrable: node.deferrable,
initiallyDeferred: node.initiallyDeferred
};
}
transformSetOperation(node, queryId) {
return {
kind: "SetOperationNode",
operator: node.operator,
expression: this.transformNode(node.expression, queryId),
all: node.all
};
}
transformReferences(node, queryId) {
return {
kind: "ReferencesNode",
table: this.transformNode(node.table, queryId),
columns: this.transformNodeList(node.columns, queryId),
onDelete: node.onDelete,
onUpdate: node.onUpdate
};
}
transformCheckConstraint(node, queryId) {
return {
kind: "CheckConstraintNode",
expression: this.transformNode(node.expression, queryId),
name: this.transformNode(node.name, queryId)
};
}
transformWith(node, queryId) {
return {
kind: "WithNode",
expressions: this.transformNodeList(node.expressions, queryId),
recursive: node.recursive
};
}
transformCommonTableExpression(node, queryId) {
return {
kind: "CommonTableExpressionNode",
name: this.transformNode(node.name, queryId),
materialized: node.materialized,
expression: this.transformNode(node.expression, queryId)
};
}
transformCommonTableExpressionName(node, queryId) {
return {
kind: "CommonTableExpressionNameNode",
table: this.transformNode(node.table, queryId),
columns: this.transformNodeList(node.columns, queryId)
};
}
transformHaving(node, queryId) {
return {
kind: "HavingNode",
having: this.transformNode(node.having, queryId)
};
}
transformCreateSchema(node, queryId) {
return {
kind: "CreateSchemaNode",
schema: this.transformNode(node.schema, queryId),
ifNotExists: node.ifNotExists
};
}
transformDropSchema(node, queryId) {
return {
kind: "DropSchemaNode",
schema: this.transformNode(node.schema, queryId),
ifExists: node.ifExists,
cascade: node.cascade
};
}
transformAlterTable(node, queryId) {
return {
kind: "AlterTableNode",
table: this.transformNode(node.table, queryId),
renameTo: this.transformNode(node.renameTo, queryId),
setSchema: this.transformNode(node.setSchema, queryId),
columnAlterations: this.transformNodeList(node.columnAlterations, queryId),
addConstraint: this.transformNode(node.addConstraint, queryId),
dropConstraint: this.transformNode(node.dropConstraint, queryId),
renameConstraint: this.transformNode(node.renameConstraint, queryId),
addIndex: this.transformNode(node.addIndex, queryId),
dropIndex: this.transformNode(node.dropIndex, queryId)
};
}
transformDropColumn(node, queryId) {
return {
kind: "DropColumnNode",
column: this.transformNode(node.column, queryId),
ifExists: node.ifExists
};
}
transformRenameColumn(node, queryId) {
return {
kind: "RenameColumnNode",
column: this.transformNode(node.column, queryId),
renameTo: this.transformNode(node.renameTo, queryId)
};
}
transformAlterColumn(node, queryId) {
return {
kind: "AlterColumnNode",
column: this.transformNode(node.column, queryId),
dataType: this.transformNode(node.dataType, queryId),
dataTypeExpression: this.transformNode(node.dataTypeExpression, queryId),
setDefault: this.transformNode(node.setDefault, queryId),
dropDefault: node.dropDefault,
setNotNull: node.setNotNull,
dropNotNull: node.dropNotNull
};
}
transformModifyColumn(node, queryId) {
return {
kind: "ModifyColumnNode",
column: this.transformNode(node.column, queryId)
};
}
transformAddConstraint(node, queryId) {
return {
kind: "AddConstraintNode",
constraint: this.transformNode(node.constraint, queryId)
};
}
transformDropConstraint(node, queryId) {
return {
kind: "DropConstraintNode",
constraintName: this.transformNode(node.constraintName, queryId),
ifExists: node.ifExists,
modifier: node.modifier
};
}
transformRenameConstraint(node, queryId) {
return {
kind: "RenameConstraintNode",
oldName: this.transformNode(node.oldName, queryId),
newName: this.transformNode(node.newName, queryId)
};
}
transformCreateView(node, queryId) {
return {
kind: "CreateViewNode",
name: this.transformNode(node.name, queryId),
temporary: node.temporary,
orReplace: node.orReplace,
ifNotExists: node.ifNotExists,
materialized: node.materialized,
columns: this.transformNodeList(node.columns, queryId),
as: this.transformNode(node.as, queryId)
};
}
transformRefreshMaterializedView(node, queryId) {
return {
kind: "RefreshMaterializedViewNode",
name: this.transformNode(node.name, queryId),
concurrently: node.concurrently,
withNoData: node.withNoData
};
}
transformDropView(node, queryId) {
return {
kind: "DropViewNode",
name: this.transformNode(node.name, queryId),
ifExists: node.ifExists,
materialized: node.materialized,
cascade: node.cascade
};
}
transformGenerated(node, queryId) {
return {
kind: "GeneratedNode",
byDefault: node.byDefault,
always: node.always,
identity: node.identity,
stored: node.stored,
expression: this.transformNode(node.expression, queryId)
};
}
transformDefaultValue(node, queryId) {
return {
kind: "DefaultValueNode",
defaultValue: this.transformNode(node.defaultValue, queryId)
};
}
transformOn(node, queryId) {
return {
kind: "OnNode",
on: this.transformNode(node.on, queryId)
};
}
transformSelectModifier(node, queryId) {
return {
kind: "SelectModifierNode",
modifier: node.modifier,
rawModifier: this.transformNode(node.rawModifier, queryId),
of: this.transformNodeList(node.of, queryId)
};
}
transformCreateType(node, queryId) {
return {
kind: "CreateTypeNode",
name: this.transformNode(node.name, queryId),
enum: this.transformNode(node.enum, queryId)
};
}
transformDropType(node, queryId) {
return {
kind: "DropTypeNode",
name: this.transformNode(node.name, queryId),
additionalNames: this.transformNodeList(node.additionalNames, queryId),
cascade: node.cascade,
ifExists: node.ifExists
};
}
transformExplain(node, queryId) {
return {
kind: "ExplainNode",
format: node.format,
options: this.transformNode(node.options, queryId)
};
}
transformSchemableIdentifier(node, queryId) {
return {
kind: "SchemableIdentifierNode",
schema: this.transformNode(node.schema, queryId),
identifier: this.transformNode(node.identifier, queryId)
};
}
transformAggregateFunction(node, queryId) {
return {
kind: "AggregateFunctionNode",
func: node.func,
aggregated: this.transformNodeList(node.aggregated, queryId),
distinct: node.distinct,
orderBy: this.transformNode(node.orderBy, queryId),
withinGroup: this.transformNode(node.withinGroup, queryId),
filter: this.transformNode(node.filter, queryId),
over: this.transformNode(node.over, queryId)
};
}
transformOver(node, queryId) {
return {
kind: "OverNode",
orderBy: this.transformNode(node.orderBy, queryId),
partitionBy: this.transformNode(node.partitionBy, queryId)
};
}
transformPartitionBy(node, queryId) {
return {
kind: "PartitionByNode",
items: this.transformNodeList(node.items, queryId)
};
}
transformPartitionByItem(node, queryId) {
return {
kind: "PartitionByItemNode",
partitionBy: this.transformNode(node.partitionBy, queryId)
};
}
transformBinaryOperation(node, queryId) {
return {
kind: "BinaryOperationNode",
leftOperand: this.transformNode(node.leftOperand, queryId),
operator: this.transformNode(node.operator, queryId),
rightOperand: this.transformNode(node.rightOperand, queryId)
};
}
transformUnaryOperation(node, queryId) {
return {
kind: "UnaryOperationNode",
operator: this.transformNode(node.operator, queryId),
operand: this.transformNode(node.operand, queryId)
};
}
transformUsing(node, queryId) {
return {
kind: "UsingNode",
tables: this.transformNodeList(node.tables, queryId)
};
}
transformFunction(node, queryId) {
return {
kind: "FunctionNode",
func: node.func,
arguments: this.transformNodeList(node.arguments, queryId)
};
}
transformCase(node, queryId) {
return {
kind: "CaseNode",
value: this.transformNode(node.value, queryId),
when: this.transformNodeList(node.when, queryId),
else: this.transformNode(node.else, queryId),
isStatement: node.isStatement
};
}
transformWhen(node, queryId) {
return {
kind: "WhenNode",
condition: this.transformNode(node.condition, queryId),
result: this.transformNode(node.result, queryId)
};
}
transformJSONReference(node, queryId) {
return {
kind: "JSONReferenceNode",
reference: this.transformNode(node.reference, queryId),
traversal: this.transformNode(node.traversal, queryId)
};
}
transformJSONPath(node, queryId) {
return {
kind: "JSONPathNode",
inOperator: this.transformNode(node.inOperator, queryId),
pathLegs: this.transformNodeList(node.pathLegs, queryId)
};
}
transformJSONPathLeg(node, _queryId) {
return {
kind: "JSONPathLegNode",
type: node.type,
value: node.value
};
}
transformJSONOperatorChain(node, queryId) {
return {
kind: "JSONOperatorChainNode",
operator: this.transformNode(node.operator, queryId),
values: this.transformNodeList(node.values, queryId)
};
}
transformTuple(node, queryId) {
return {
kind: "TupleNode",
values: this.transformNodeList(node.values, queryId)
};
}
transformMergeQuery(node, queryId) {
return {
kind: "MergeQueryNode",
into: this.transformNode(node.into, queryId),
using: this.transformNode(node.using, queryId),
whens: this.transformNodeList(node.whens, queryId),
with: this.transformNode(node.with, queryId),
top: this.transformNode(node.top, queryId),
endModifiers: this.transformNodeList(node.endModifiers, queryId),
output: this.transformNode(node.output, queryId),
returning: this.transformNode(node.returning, queryId)
};
}
transformMatched(node, _queryId) {
return {
kind: "MatchedNode",
not: node.not,
bySource: node.bySource
};
}
transformAddIndex(node, queryId) {
return {
kind: "AddIndexNode",
name: this.transformNode(node.name, queryId),
columns: this.transformNodeList(node.columns, queryId),
unique: node.unique,
using: this.transformNode(node.using, queryId),
ifNotExists: node.ifNotExists
};
}
transformCast(node, queryId) {
return {
kind: "CastNode",
expression: this.transformNode(node.expression, queryId),
dataType: this.transformNode(node.dataType, queryId)
};
}
transformFetch(node, queryId) {
return {
kind: "FetchNode",
rowCount: this.transformNode(node.rowCount, queryId),
modifier: node.modifier
};
}
transformTop(node, _queryId) {
return {
kind: "TopNode",
expression: node.expression,
modifiers: node.modifiers
};
}
transformOutput(node, queryId) {
return {
kind: "OutputNode",
selections: this.transformNodeList(node.selections, queryId)
};
}
transformAlterType(node, queryId) {
return {
kind: "AlterTypeNode",
name: this.transformNode(node.name, queryId),
addValue: this.transformNode(node.addValue, queryId),
renameTo: this.transformNode(node.renameTo, queryId),
renameValue: this.transformNode(node.renameValue, queryId),
setSchema: this.transformNode(node.setSchema, queryId)
};
}
transformAddValue(node, queryId) {
return {
kind: "AddValueNode",
value: this.transformNode(node.value, queryId),
ifNotExists: node.ifNotExists,
isBefore: node.isBefore,
neighborValue: this.transformNode(node.neighborValue, queryId)
};
}
transformRenameValue(node, queryId) {
return {
kind: "RenameValueNode",
oldValue: this.transformNode(node.oldValue, queryId),
newValue: this.transformNode(node.newValue, queryId)
};
}
transformDataType(node, _queryId) {
return node;
}
transformSelectAll(node, _queryId) {
return node;
}
transformIdentifier(node, _queryId) {
return node;
}
transformValue(node, _queryId) {
return node;
}
transformPrimitiveValueList(node, _queryId) {
return node;
}
transformOperator(node, _queryId) {
return node;
}
transformDefaultInsertValue(node, _queryId) {
return node;
}
transformOrAction(node, _queryId) {
return node;
}
transformCollate(node, _queryId) {
return node;
}
}
// server/node_modules/kysely/dist/operation-node/operation-node.js
function isOperationNode(thing) {
return isObject(thing) && isString(thing.kind);
}
// server/node_modules/kysely/dist/operation-node/root-operation-node.js
var ROOT_OPERATION_NODE_KINDS = {
AlterTableNode: true,
AlterTypeNode: true,
CreateIndexNode: true,
CreateSchemaNode: true,
CreateTableNode: true,
CreateTypeNode: true,
CreateViewNode: true,
DeleteQueryNode: true,
DropIndexNode: true,
DropSchemaNode: true,
DropTableNode: true,
DropTypeNode: true,
RefreshMaterializedViewNode: true,
DropViewNode: true,
InsertQueryNode: true,
RawNode: true,
SelectQueryNode: true,
UpdateQueryNode: true,
MergeQueryNode: true
};
function isRootOperationNode(thing) {
return isOperationNode(thing) && ROOT_OPERATION_NODE_KINDS[thing.kind] === true;
}
// server/node_modules/kysely/dist/plugin/with-schema/with-schema-transformer.js
var SCHEMALESS_FUNCTIONS = freeze({
json_agg: true,
to_json: true
});
class WithSchemaTransformer extends OperationNodeTransformer {
#schema;
#schemableIds = new Set;
#ctes = new Set;
constructor(schema) {
super();
this.#schema = schema;
}
transformNodeImpl(node, queryId) {
if (!isRootOperationNode(node)) {
return super.transformNodeImpl(node, queryId);
}
const ctes = this.#collectCTEs(node);
for (const cte of ctes) {
this.#ctes.add(cte);
}
const tables = this.#collectSchemableIds(node);
for (const table of tables) {
this.#schemableIds.add(table);
}
const transformed = super.transformNodeImpl(node, queryId);
for (const table of tables) {
this.#schemableIds.delete(table);
}
for (const cte of ctes) {
this.#ctes.delete(cte);
}
return transformed;
}
transformSchemableIdentifier(node, queryId) {
const transformed = super.transformSchemableIdentifier(node, queryId);
if (transformed.schema || !this.#schemableIds.has(node.identifier.name)) {
return transformed;
}
return {
...transformed,
schema: IdentifierNode.create(this.#schema)
};
}
transformReferences(node, queryId) {
const transformed = super.transformReferences(node, queryId);
if (transformed.table.table.schema) {
return transformed;
}
return {
...transformed,
table: TableNode.createWithSchema(this.#schema, transformed.table.table.identifier.name)
};
}
transformAggregateFunction(node, queryId) {
return {
...super.transformAggregateFunction({ ...node, aggregated: [] }, queryId),
aggregated: this.#transformTableArgsWithoutSchemas(node, queryId, "aggregated")
};
}
transformFunction(node, queryId) {
return {
...super.transformFunction({ ...node, arguments: [] }, queryId),
arguments: this.#transformTableArgsWithoutSchemas(node, queryId, "arguments")
};
}
transformSelectModifier(node, queryId) {
return {
...super.transformSelectModifier({ ...node, of: undefined }, queryId),
of: node.of?.map((item) => TableNode.is(item) && !item.table.schema ? {
...item,
table: this.transformIdentifier(item.table.identifier, queryId)
} : this.transformNode(item, queryId))
};
}
#transformTableArgsWithoutSchemas(node, queryId, argsKey) {
return SCHEMALESS_FUNCTIONS[node.func] ? node[argsKey].map((arg) => !TableNode.is(arg) || arg.table.schema ? this.transformNode(arg, queryId) : {
...arg,
table: this.transformIdentifier(arg.table.identifier, queryId)
}) : this.transformNodeList(node[argsKey], queryId);
}
#collectSchemableIds(node) {
const schemableIds = new Set;
if ("name" in node && node.name && SchemableIdentifierNode.is(node.name)) {
this.#collectSchemableId(node.name, schemableIds);
}
if ("from" in node && node.from) {
for (const from of node.from.froms) {
this.#collectSchemableIdsFromTableExpr(from, schemableIds);
}
}
if ("into" in node && node.into) {
this.#collectSchemableIdsFromTableExpr(node.into, schemableIds);
}
if ("table" in node && node.table) {
this.#collectSchemableIdsFromTableExpr(node.table, schemableIds);
}
if ("joins" in node && node.joins) {
for (const join of node.joins) {
this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
}
}
if ("using" in node && node.using) {
if (JoinNode.is(node.using)) {
this.#collectSchemableIdsFromTableExpr(node.using.table, schemableIds);
} else {
this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
}
}
return schemableIds;
}
#collectCTEs(node) {
const ctes = new Set;
if ("with" in node && node.with) {
this.#collectCTEIds(node.with, ctes);
}
return ctes;
}
#collectSchemableIdsFromTableExpr(node, schemableIds) {
if (TableNode.is(node)) {
return this.#collectSchemableId(node.table, schemableIds);
}
if (AliasNode.is(node) && TableNode.is(node.node)) {
return this.#collectSchemableId(node.node.table, schemableIds);
}
if (ListNode.is(node)) {
for (const table of node.items) {
this.#collectSchemableIdsFromTableExpr(table, schemableIds);
}
return;
}
if (UsingNode.is(node)) {
for (const table of node.tables) {
this.#collectSchemableIdsFromTableExpr(table, schemableIds);
}
return;
}
}
#collectSchemableId(node, schemableIds) {
const id = node.identifier.name;
if (!this.#schemableIds.has(id) && !this.#ctes.has(id)) {
schemableIds.add(id);
}
}
#collectCTEIds(node, ctes) {
for (const expr of node.expressions) {
const cteId = expr.name.table.table.identifier.name;
if (!this.#ctes.has(cteId)) {
ctes.add(cteId);
}
}
}
}
// server/node_modules/kysely/dist/plugin/with-schema/with-schema-plugin.js
class WithSchemaPlugin {
#transformer;
constructor(schema) {
this.#transformer = new WithSchemaTransformer(schema);
}
transformQuery(args) {
return this.#transformer.transformNode(args.node, args.queryId);
}
async transformResult(args) {
return args.result;
}
}
// server/node_modules/kysely/dist/operation-node/matched-node.js
var MatchedNode = freeze({
is(node) {
return node.kind === "MatchedNode";
},
create(not, bySource = false) {
return freeze({
kind: "MatchedNode",
not,
bySource
});
}
});
// server/node_modules/kysely/dist/parser/merge-parser.js
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));
}
function parseMergeThen(result) {
if (isString(result)) {
return RawNode.create([result], []);
}
if (isOperationNodeSource(result)) {
return result.toOperationNode();
}
return result;
}
// server/node_modules/kysely/dist/util/deferred.js
class Deferred {
#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 = undefined;
};
reject = (reason) => {
this.#reject?.(reason);
this.#reject = this.#resolve = undefined;
};
}
// server/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
});
}
// server/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) {
beforeThrow();
throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.killSession ? "kill session" : undefined);
}
return handler.bind(connection);
}
if (abortStrategy === "kill session") {
const handler = connection.killSession;
if (!handler) {
beforeThrow();
throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.cancelQuery ? "cancel query" : undefined);
}
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;
}
var ABORTED = {};
async function waitOrAbort(promise, signal, name, onAbort) {
if (!signal) {
return promise;
}
assertNotAborted(signal, `before ${name}`, onAbort);
const { promise: abortPromise, resolve } = new Deferred;
const abortListener = () => resolve(ABORTED);
signal.addEventListener("abort", abortListener);
try {
assertNotAborted(signal, `before ${name}`, onAbort);
const result = await Promise.race([promise, abortPromise]);
if (result !== ABORTED) {
return result;
}
onAbort?.();
throwReasonWithTiming(signal.reason, `during ${name}`);
} finally {
signal.removeEventListener("abort", abortListener);
resolve(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
});
}
}
// server/node_modules/kysely/dist/query-executor/query-executor-base.js
var NO_PLUGINS = freeze([]);
class QueryExecutorBase {
#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 (connection2) => {
return await connection2.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, release);
if (inflightQueryAbortHandler && connection.collectSessionInfo) {
assertNotAborted(signal, "before query execution", release);
const collectPromise = connection.collectSessionInfo();
const result2 = await Promise.race([abortPromise, collectPromise]).catch((error) => {
release();
throw error;
});
if (result2 === ABORTED) {
collectPromise.catch(printBackgroundFail("collectSessionInfo")).finally(release);
throwReasonWithTiming(signal.reason, "before query execution");
}
}
const queryPromise = connection.executeQuery(compiledQuery, options);
const result = await Promise.race([abortPromise, queryPromise]).catch((error) => {
release();
throw error;
});
if (result === ABORTED) {
Promise.allSettled([
queryPromise.catch(printBackgroundFail("query")),
inflightQueryAbortHandler?.(controlConnectionProvider).catch(printBackgroundFail("inflightQueryAbortHandler"))
]).finally(release);
throwReasonWithTiming(signal.reason, "during query execution");
} else {
release();
}
const transformPromise = this.#transformResult(result, compiledQuery.queryId, options);
const transformedResult = await Promise.race([
abortPromise,
transformPromise
]);
if (transformedResult === ABORTED) {
transformPromise.catch(printBackgroundFail("plugins.transformResult"));
throwReasonWithTiming(signal.reason, "during result transformation");
}
return transformedResult;
} finally {
resolve(ABORTED);
signal.removeEventListener("abort", abortListener);
}
}
async* stream(compiledQuery, chunkSize, options) {
const { signal } = options || {};
if (!signal) {
const { connection: connection2, release: release2 } = await provideControlledConnection(this);
try {
for await (const result of connection2.streamQuery(compiledQuery, chunkSize)) {
yield await this.#transformResult(result, compiledQuery.queryId, options);
}
} finally {
release2();
}
return;
}
options = freeze({ signal });
assertNotAborted(signal, "before connection acquisition");
const { connection, release } = await provideControlledConnection(this, options);
const { promise: abortPromise, resolve } = new Deferred;
const abortListener = () => resolve(ABORTED);
signal.addEventListener("abort", abortListener, { once: true });
let asyncIterator;
let releasePrerequisite;
assertNotAborted(signal, "before query streaming", release);
const { queryId } = compiledQuery;
try {
asyncIterator = connection.streamQuery(compiledQuery, chunkSize, options);
while (true) {
assertNotAborted(signal, "during query streaming");
const nextPromise = asyncIterator.next();
const result = await Promise.race([abortPromise, nextPromise]);
if (result === ABORTED) {
releasePrerequisite = nextPromise.catch(printBackgroundFail("iterator.next"));
throwReasonWithTiming(signal.reason, "during query streaming");
}
if (result.done) {
break;
}
const transformPromise = this.#transformResult(result.value, queryId, options);
const transformedResult = await Promise.race([
abortPromise,
transformPromise
]);
if (transformedResult === ABORTED) {
releasePrerequisite = transformPromise.catch(printBackgroundFail("plugins.transformResult"));
throwReasonWithTiming(signal.reason, "during result transformation");
}
yield transformedResult;
}
} finally {
resolve(ABORTED);
signal.removeEventListener("abort", abortListener);
const cleanup = (asyncIterator?.return?.() || Promise.resolve()).finally(() => releasePrerequisite).finally(release);
if (!releasePrerequisite) {
await cleanup;
}
}
}
async#transformResult(result, queryId, options) {
const { signal } = options || {};
for (const plugin of this.#plugins) {
result = await plugin.transformResult(freeze({ queryId, result, signal }));
}
return result;
}
}
// server/node_modules/kysely/dist/query-executor/noop-query-executor.js
class NoopQueryExecutor extends QueryExecutorBase {
get adapter() {
throw new Error("this query cannot be compiled to SQL");
}
compileQuery() {
throw new Error("this query cannot be compiled to SQL");
}
provideConnection() {
throw new Error("this query cannot be executed");
}
withConnectionProvider() {
throw new Error("this query cannot have a connection provider");
}
withPlugin(plugin) {
return new NoopQueryExecutor([...this.plugins, plugin]);
}
withPlugins(plugins) {
return new NoopQueryExecutor([...this.plugins, ...plugins]);
}
withPluginAtFront(plugin) {
return new NoopQueryExecutor([plugin, ...this.plugins]);
}
withoutPlugins() {
return new NoopQueryExecutor([]);
}
}
var NOOP_QUERY_EXECUTOR = new NoopQueryExecutor;
// server/node_modules/kysely/dist/query-builder/merge-result.js
class MergeResult {
numChangedRows;
constructor(numChangedRows) {
this.numChangedRows = numChangedRows;
}
}
// server/node_modules/kysely/dist/query-builder/merge-query-builder.js
class MergeQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
modifyEnd(modifier) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
});
}
top(expression, modifiers) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
using(...args) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithUsing(this.#props.queryNode, parseJoin("Using", args))
});
}
returning(args) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(args))
});
}
returningAll(table) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
});
}
output(args) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
});
}
outputAll(table) {
return new MergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
});
}
}
class WheneableMergeQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
modifyEnd(modifier) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode())
});
}
top(expression, modifiers) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
whenMatched() {
return this.#whenMatched([]);
}
whenMatchedAnd(...args) {
return this.#whenMatched(args);
}
whenMatchedAndRef(lhs, op, rhs) {
return this.#whenMatched([lhs, op, rhs], true);
}
#whenMatched(args, refRight) {
return new MatchedThenableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithWhen(this.#props.queryNode, parseMergeWhen({ isMatched: true }, args, refRight))
});
}
whenNotMatched() {
return this.#whenNotMatched([]);
}
whenNotMatchedAnd(...args) {
return this.#whenNotMatched(args);
}
whenNotMatchedAndRef(lhs, op, rhs) {
return this.#whenNotMatched([lhs, op, rhs], true);
}
whenNotMatchedBySource() {
return this.#whenNotMatched([], false, true);
}
whenNotMatchedBySourceAnd(...args) {
return this.#whenNotMatched(args, false, true);
}
whenNotMatchedBySourceAndRef(lhs, op, rhs) {
return this.#whenNotMatched([lhs, op, rhs], true, true);
}
returning(args) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(args))
});
}
returningAll(table) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table))
});
}
output(args) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args))
});
}
outputAll(table) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table))
});
}
#whenNotMatched(args, refRight = false, bySource = false) {
const props = {
...this.#props,
queryNode: MergeQueryNode.cloneWithWhen(this.#props.queryNode, parseMergeWhen({ isMatched: false, bySource }, args, refRight))
};
const Builder = bySource ? MatchedThenableMergeQueryBuilder : NotMatchedThenableMergeQueryBuilder;
return new Builder(props);
}
$call(func) {
return func(this);
}
$if(condition, func) {
if (condition) {
return func(this);
}
return new WheneableMergeQueryBuilder({
...this.#props
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
const compiledQuery = this.compile();
const result = await this.#props.executor.executeQuery(compiledQuery, options);
const { adapter } = this.#props.executor;
const query = compiledQuery.query;
if (query.returning && adapter.supportsReturning || query.output && adapter.supportsOutput) {
return result.rows;
}
return [new MergeResult(result.numAffectedRows)];
}
async executeTakeFirst(options) {
const [result] = await this.execute(options);
return result;
}
async executeTakeFirstOrThrow(errorConstructorOrOptions) {
if (typeof errorConstructorOrOptions === "function") {
errorConstructorOrOptions = {
errorConstructor: errorConstructorOrOptions
};
}
const result = await this.executeTakeFirst(errorConstructorOrOptions);
if (result === undefined) {
const errorConstructor = errorConstructorOrOptions?.errorConstructor ?? NoResultError;
const error = isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
throw error;
}
return result;
}
}
class MatchedThenableMergeQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
thenDelete() {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen("delete"))
});
}
thenDoNothing() {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen("do nothing"))
});
}
thenUpdate(set) {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen(set(new UpdateQueryBuilder({
queryId: this.#props.queryId,
executor: NOOP_QUERY_EXECUTOR,
queryNode: UpdateQueryNode.createWithoutTable()
}))))
});
}
thenUpdateSet(...args) {
return this.thenUpdate((ub) => ub.set(...args));
}
}
class NotMatchedThenableMergeQueryBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
thenDoNothing() {
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen("do nothing"))
});
}
thenInsertValues(insert) {
const [columns, values] = parseInsertExpression(insert);
return new WheneableMergeQueryBuilder({
...this.#props,
queryNode: MergeQueryNode.cloneWithThen(this.#props.queryNode, parseMergeThen(InsertQueryNode.cloneWith(InsertQueryNode.createWithoutInto(), {
columns,
values
})))
});
}
}
// server/node_modules/kysely/dist/query-creator.js
class QueryCreator {
#props;
constructor(props) {
this.#props = freeze(props);
}
selectFrom(from) {
return createSelectQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(from), this.#props.withNode)
});
}
selectNoFrom(selection) {
return createSelectQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: SelectQueryNode.cloneWithSelections(SelectQueryNode.create(this.#props.withNode), parseSelectArg(selection))
});
}
insertInto(table) {
return new InsertQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode)
});
}
replaceInto(table) {
return new InsertQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true)
});
}
deleteFrom(from) {
return new DeleteQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: DeleteQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode)
});
}
updateTable(tables) {
return new UpdateQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: UpdateQueryNode.create(parseTableExpressionOrList(tables), this.#props.withNode)
});
}
mergeInto(targetTable) {
return new MergeQueryBuilder({
queryId: createQueryId(),
executor: this.#props.executor,
queryNode: MergeQueryNode.create(parseAliasedTable(targetTable), this.#props.withNode)
});
}
with(nameOrBuilder, expression) {
const cte = parseCommonTableExpression(nameOrBuilder, expression);
return new QueryCreator({
...this.#props,
withNode: this.#props.withNode ? WithNode.cloneWithExpression(this.#props.withNode, cte) : WithNode.create(cte)
});
}
withRecursive(nameOrBuilder, expression) {
const cte = parseCommonTableExpression(nameOrBuilder, expression);
return new QueryCreator({
...this.#props,
withNode: this.#props.withNode ? WithNode.cloneWithExpression(this.#props.withNode, cte) : WithNode.create(cte, { recursive: true })
});
}
withPlugin(plugin) {
return new QueryCreator({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
withoutPlugins() {
return new QueryCreator({
...this.#props,
executor: this.#props.executor.withoutPlugins()
});
}
withSchema(schema) {
return new QueryCreator({
...this.#props,
executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
});
}
}
// server/node_modules/kysely/dist/parser/parse-utils.js
function createQueryCreator() {
return new QueryCreator({
executor: NOOP_QUERY_EXECUTOR
});
}
function createJoinBuilder(joinType, table) {
return new JoinBuilder({
joinNode: JoinNode.create(joinType, parseTableExpression(table))
});
}
function createOverBuilder() {
return new OverBuilder({
overNode: OverNode.create()
});
}
// server/node_modules/kysely/dist/parser/join-parser.js
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));
}
// server/node_modules/kysely/dist/operation-node/offset-node.js
var OffsetNode = freeze({
is(node) {
return node.kind === "OffsetNode";
},
create(offset) {
return freeze({
kind: "OffsetNode",
offset
});
}
});
// server/node_modules/kysely/dist/operation-node/group-by-item-node.js
var GroupByItemNode = freeze({
is(node) {
return node.kind === "GroupByItemNode";
},
create(groupBy) {
return freeze({
kind: "GroupByItemNode",
groupBy
});
}
});
// server/node_modules/kysely/dist/parser/group-by-parser.js
function parseGroupBy(groupBy) {
groupBy = isFunction(groupBy) ? groupBy(expressionBuilder()) : groupBy;
return parseReferenceExpressionOrList(groupBy).map(GroupByItemNode.create);
}
// server/node_modules/kysely/dist/operation-node/set-operation-node.js
var SetOperationNode = freeze({
is(node) {
return node.kind === "SetOperationNode";
},
create(operator, expression, all) {
return freeze({
kind: "SetOperationNode",
operator,
expression,
all
});
}
});
// server/node_modules/kysely/dist/parser/set-operation-parser.js
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));
}
// server/node_modules/kysely/dist/expression/expression-wrapper.js
class ExpressionWrapper {
#node;
constructor(node) {
this.#node = node;
}
get expressionType() {
return;
}
as(alias) {
return new AliasedExpressionWrapper(this, alias);
}
or(...args) {
return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
}
and(...args) {
return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
}
$castTo() {
return new ExpressionWrapper(this.#node);
}
$notNull() {
return new ExpressionWrapper(this.#node);
}
toOperationNode() {
return this.#node;
}
}
class AliasedExpressionWrapper {
#expr;
#alias;
constructor(expr, alias) {
this.#expr = expr;
this.#alias = alias;
}
get expression() {
return this.#expr;
}
get alias() {
return this.#alias;
}
toOperationNode() {
return AliasNode.create(this.#expr.toOperationNode(), isOperationNodeSource(this.#alias) ? this.#alias.toOperationNode() : IdentifierNode.create(this.#alias));
}
}
class OrWrapper {
#node;
constructor(node) {
this.#node = node;
}
get expressionType() {
return;
}
as(alias) {
return new AliasedExpressionWrapper(this, alias);
}
or(...args) {
return new OrWrapper(OrNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
}
$castTo() {
return new OrWrapper(this.#node);
}
toOperationNode() {
return ParensNode.create(this.#node);
}
}
class AndWrapper {
#node;
constructor(node) {
this.#node = node;
}
get expressionType() {
return;
}
as(alias) {
return new AliasedExpressionWrapper(this, alias);
}
and(...args) {
return new AndWrapper(AndNode.create(this.#node, parseValueBinaryOperationOrExpression(args)));
}
$castTo() {
return new AndWrapper(this.#node);
}
toOperationNode() {
return ParensNode.create(this.#node);
}
}
// server/node_modules/kysely/dist/operation-node/fetch-node.js
var FetchNode = freeze({
is(node) {
return node.kind === "FetchNode";
},
create(rowCount, modifier) {
return {
kind: "FetchNode",
rowCount: ValueNode.create(rowCount),
modifier
};
}
});
// server/node_modules/kysely/dist/parser/fetch-parser.js
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";
}
// server/node_modules/kysely/dist/query-builder/select-query-builder.js
var _a3;
class SelectQueryBuilderImpl {
#props;
constructor(props) {
this.#props = freeze(props);
}
get expressionType() {
return;
}
get isSelectQueryBuilder() {
return true;
}
where(...args) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args))
});
}
whereRef(lhs, op, rhs) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
having(...args) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseValueBinaryOperationOrExpression(args))
});
}
havingRef(lhs, op, rhs) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
select(selection) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectArg(selection))
});
}
distinctOn(selection) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithDistinctOn(this.#props.queryNode, parseReferenceExpressionOrList(selection))
});
}
modifyFront(modifier) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode()))
});
}
modifyEnd(modifier) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode()))
});
}
distinct() {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.create("Distinct"))
});
}
forUpdate(of) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("ForUpdate", of ? asArray(of).map(parseTable) : undefined))
});
}
forShare(of) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("ForShare", of ? asArray(of).map(parseTable) : undefined))
});
}
forKeyShare(of) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("ForKeyShare", of ? asArray(of).map(parseTable) : undefined))
});
}
forNoKeyUpdate(of) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("ForNoKeyUpdate", of ? asArray(of).map(parseTable) : undefined))
});
}
skipLocked() {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("SkipLocked"))
});
}
noWait() {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create("NoWait"))
});
}
selectAll(table) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAll(table))
});
}
innerJoin(...args) {
return this.#join("InnerJoin", args);
}
leftJoin(...args) {
return this.#join("LeftJoin", args);
}
rightJoin(...args) {
return this.#join("RightJoin", args);
}
fullJoin(...args) {
return this.#join("FullJoin", args);
}
crossJoin(...args) {
return this.#join("CrossJoin", args);
}
innerJoinLateral(...args) {
return this.#join("LateralInnerJoin", args);
}
leftJoinLateral(...args) {
return this.#join("LateralLeftJoin", args);
}
crossJoinLateral(...args) {
return this.#join("LateralCrossJoin", args);
}
crossApply(...args) {
return this.#join("CrossApply", args);
}
outerApply(...args) {
return this.#join("OuterApply", args);
}
#join(joinType, args) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args))
});
}
orderBy(...args) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args))
});
}
groupBy(groupBy) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseGroupBy(groupBy))
});
}
limit(limit) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(parseValueExpression(limit)))
});
}
offset(offset) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(parseValueExpression(offset)))
});
}
fetch(rowCount, modifier = "only") {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithFetch(this.#props.queryNode, parseFetch(rowCount, modifier))
});
}
top(expression, modifiers) {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithTop(this.#props.queryNode, parseTop(expression, modifiers))
});
}
union(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("union", expression, false))
});
}
unionAll(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("union", expression, true))
});
}
intersect(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("intersect", expression, false))
});
}
intersectAll(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("intersect", expression, true))
});
}
except(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("except", expression, false))
});
}
exceptAll(expression) {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations("except", expression, true))
});
}
as(alias) {
return new AliasedSelectQueryBuilderImpl(this, alias);
}
clearSelect() {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithoutSelections(this.#props.queryNode)
});
}
clearWhere() {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode)
});
}
clearLimit() {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithoutLimit(this.#props.queryNode)
});
}
clearOffset() {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithoutOffset(this.#props.queryNode)
});
}
clearOrderBy() {
return new _a3({
...this.#props,
queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode)
});
}
clearGroupBy() {
return new _a3({
...this.#props,
queryNode: SelectQueryNode.cloneWithoutGroupBy(this.#props.queryNode)
});
}
$call(func) {
return func(this);
}
$if(condition, func) {
if (condition) {
return func(this);
}
return new _a3({
...this.#props
});
}
$castTo() {
return new _a3(this.#props);
}
$narrowType() {
return new _a3(this.#props);
}
$assertType() {
return new _a3(this.#props);
}
$asTuple() {
return new ExpressionWrapper(this.toOperationNode());
}
$asScalar() {
return new ExpressionWrapper(this.toOperationNode());
}
withPlugin(plugin) {
return new _a3({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
const compiledQuery = this.compile();
const result = await this.#props.executor.executeQuery(compiledQuery, options);
return result.rows;
}
async executeTakeFirst(options) {
const [result] = await this.execute(options);
return result;
}
async executeTakeFirstOrThrow(errorConstructorOrOptions) {
if (typeof errorConstructorOrOptions === "function") {
errorConstructorOrOptions = {
errorConstructor: errorConstructorOrOptions
};
}
const result = await this.executeTakeFirst(errorConstructorOrOptions);
if (result === undefined) {
const errorConstructor = errorConstructorOrOptions?.errorConstructor ?? NoResultError;
const error = isNoResultErrorConstructor(errorConstructor) ? new errorConstructor(this.toOperationNode()) : errorConstructor(this.toOperationNode());
throw error;
}
return result;
}
async* stream(chunkSizeOrOptions) {
if (typeof chunkSizeOrOptions !== "object") {
chunkSizeOrOptions = {
chunkSize: chunkSizeOrOptions
};
}
const compiledQuery = this.compile();
const stream = this.#props.executor.stream(compiledQuery, chunkSizeOrOptions.chunkSize ?? 100, chunkSizeOrOptions);
for await (const item of stream) {
yield* item.rows;
}
}
async explain(format, options) {
const builder = new _a3({
...this.#props,
queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options)
});
return await builder.execute();
}
}
_a3 = SelectQueryBuilderImpl;
function createSelectQueryBuilder(props) {
return new SelectQueryBuilderImpl(props);
}
class AliasedSelectQueryBuilderImpl {
#queryBuilder;
#alias;
constructor(queryBuilder, alias) {
this.#queryBuilder = queryBuilder;
this.#alias = alias;
}
get expression() {
return this.#queryBuilder;
}
get alias() {
return this.#alias;
}
get isAliasedSelectQueryBuilder() {
return true;
}
toOperationNode() {
return AliasNode.create(this.#queryBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
}
}
// server/node_modules/kysely/dist/operation-node/aggregate-function-node.js
var AggregateFunctionNode = freeze({
is(node) {
return node.kind === "AggregateFunctionNode";
},
create(aggregateFunction, aggregated = []) {
return freeze({
kind: "AggregateFunctionNode",
func: aggregateFunction,
aggregated
});
},
cloneWithDistinct(aggregateFunctionNode) {
return freeze({
...aggregateFunctionNode,
distinct: true
});
},
cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
const prop = withinGroup ? "withinGroup" : "orderBy";
return freeze({
...aggregateFunctionNode,
[prop]: aggregateFunctionNode[prop] ? OrderByNode.cloneWithItems(aggregateFunctionNode[prop], orderItems) : OrderByNode.create(orderItems)
});
},
cloneWithFilter(aggregateFunctionNode, filter) {
return freeze({
...aggregateFunctionNode,
filter: aggregateFunctionNode.filter ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, "And", filter) : WhereNode.create(filter)
});
},
cloneWithOrFilter(aggregateFunctionNode, filter) {
return freeze({
...aggregateFunctionNode,
filter: aggregateFunctionNode.filter ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, "Or", filter) : WhereNode.create(filter)
});
},
cloneWithOver(aggregateFunctionNode, over) {
return freeze({
...aggregateFunctionNode,
over
});
}
});
// server/node_modules/kysely/dist/operation-node/function-node.js
var FunctionNode = freeze({
is(node) {
return node.kind === "FunctionNode";
},
create(func, args) {
return freeze({
kind: "FunctionNode",
func,
arguments: args
});
}
});
// server/node_modules/kysely/dist/query-builder/aggregate-function-builder.js
class AggregateFunctionBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
get expressionType() {
return;
}
as(alias) {
return new AliasedAggregateFunctionBuilder(this, alias);
}
distinct() {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode)
});
}
orderBy(...args) {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: QueryNode.cloneWithOrderByItems(this.#props.aggregateFunctionNode, parseOrderBy(args))
});
}
clearOrderBy() {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: QueryNode.cloneWithoutOrderBy(this.#props.aggregateFunctionNode)
});
}
withinGroupOrderBy(...args) {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: AggregateFunctionNode.cloneWithOrderBy(this.#props.aggregateFunctionNode, parseOrderBy(args), true)
});
}
filterWhere(...args) {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseValueBinaryOperationOrExpression(args))
});
}
filterWhereRef(lhs, op, rhs) {
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialBinaryOperation(lhs, op, rhs))
});
}
over(over) {
const builder = createOverBuilder();
return new AggregateFunctionBuilder({
...this.#props,
aggregateFunctionNode: AggregateFunctionNode.cloneWithOver(this.#props.aggregateFunctionNode, (over ? over(builder) : builder).toOperationNode())
});
}
$call(func) {
return func(this);
}
$castTo() {
return new AggregateFunctionBuilder(this.#props);
}
$notNull() {
return new AggregateFunctionBuilder(this.#props);
}
toOperationNode() {
return this.#props.aggregateFunctionNode;
}
}
class AliasedAggregateFunctionBuilder {
#aggregateFunctionBuilder;
#alias;
constructor(aggregateFunctionBuilder, alias) {
this.#aggregateFunctionBuilder = aggregateFunctionBuilder;
this.#alias = alias;
}
get expression() {
return this.#aggregateFunctionBuilder;
}
get alias() {
return this.#alias;
}
toOperationNode() {
return AliasNode.create(this.#aggregateFunctionBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
}
}
// server/node_modules/kysely/dist/query-builder/function-module.js
function createFunctionModule() {
const fn = (name, args) => {
return new ExpressionWrapper(FunctionNode.create(name, parseReferenceExpressionOrList(args ?? [])));
};
const agg = (name, args) => {
return new AggregateFunctionBuilder({
aggregateFunctionNode: AggregateFunctionNode.create(name, args ? parseReferenceExpressionOrList(args) : undefined)
});
};
return Object.assign(fn, {
agg,
avg(column) {
return agg("avg", [column]);
},
coalesce(...values) {
return fn("coalesce", values);
},
count(column) {
return agg("count", [column]);
},
countAll(table) {
return new AggregateFunctionBuilder({
aggregateFunctionNode: AggregateFunctionNode.create("count", parseSelectAll(table))
});
},
max(column) {
return agg("max", [column]);
},
min(column) {
return agg("min", [column]);
},
sum(column) {
return agg("sum", [column]);
},
any(column) {
return fn("any", [column]);
},
jsonAgg(table) {
return new AggregateFunctionBuilder({
aggregateFunctionNode: AggregateFunctionNode.create("json_agg", [
isString(table) ? parseTable(table) : table.toOperationNode()
])
});
},
toJson(table) {
return new ExpressionWrapper(FunctionNode.create("to_json", [
isString(table) ? parseTable(table) : table.toOperationNode()
]));
}
});
}
// server/node_modules/kysely/dist/operation-node/unary-operation-node.js
var UnaryOperationNode = freeze({
is(node) {
return node.kind === "UnaryOperationNode";
},
create(operator, operand) {
return freeze({
kind: "UnaryOperationNode",
operator,
operand
});
}
});
// server/node_modules/kysely/dist/parser/unary-operation-parser.js
function parseUnaryOperation(operator, operand) {
if (isUnaryOperator(operator)) {
return UnaryOperationNode.create(OperatorNode.create(operator), parseReferenceExpression(operand));
}
throw new Error(`invalid unary operator ${JSON.stringify(operator)}`);
}
// server/node_modules/kysely/dist/operation-node/case-node.js
var CaseNode = freeze({
is(node) {
return node.kind === "CaseNode";
},
create(value) {
return freeze({
kind: "CaseNode",
value
});
},
cloneWithWhen(caseNode, when) {
return freeze({
...caseNode,
when: freeze(caseNode.when ? [...caseNode.when, when] : [when])
});
},
cloneWithThen(caseNode, then) {
return freeze({
...caseNode,
when: caseNode.when ? freeze([
...caseNode.when.slice(0, -1),
WhenNode.cloneWithResult(caseNode.when[caseNode.when.length - 1], then)
]) : undefined
});
},
cloneWith(caseNode, props) {
return freeze({
...caseNode,
...props
});
}
});
// server/node_modules/kysely/dist/query-builder/case-builder.js
class CaseBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
when(...args) {
return new CaseThenBuilder({
...this.#props,
node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args)))
});
}
whenRef(lhs, op, rhs) {
return new CaseThenBuilder({
...this.#props,
node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseReferentialBinaryOperation(lhs, op, rhs)))
});
}
}
class CaseThenBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
then(valueExpression) {
return new CaseWhenBuilder({
...this.#props,
node: CaseNode.cloneWithThen(this.#props.node, isSafeImmediateValue(valueExpression) ? parseSafeImmediateValue(valueExpression) : parseValueExpression(valueExpression))
});
}
thenRef(expression) {
return new CaseWhenBuilder({
...this.#props,
node: CaseNode.cloneWithThen(this.#props.node, parseReferenceExpression(expression))
});
}
}
class CaseWhenBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
when(...args) {
return new CaseThenBuilder({
...this.#props,
node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args)))
});
}
whenRef(lhs, op, rhs) {
return new CaseThenBuilder({
...this.#props,
node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseReferentialBinaryOperation(lhs, op, rhs)))
});
}
else(valueExpression) {
return new CaseEndBuilder({
...this.#props,
node: CaseNode.cloneWith(this.#props.node, {
else: isSafeImmediateValue(valueExpression) ? parseSafeImmediateValue(valueExpression) : parseValueExpression(valueExpression)
})
});
}
elseRef(expression) {
return new CaseEndBuilder({
...this.#props,
node: CaseNode.cloneWith(this.#props.node, {
else: parseReferenceExpression(expression)
})
});
}
end() {
return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
}
endCase() {
return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
}
}
class CaseEndBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
end() {
return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
}
endCase() {
return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
}
}
// server/node_modules/kysely/dist/operation-node/json-path-leg-node.js
var JSONPathLegNode = freeze({
is(node) {
return node.kind === "JSONPathLegNode";
},
create(type, value) {
return freeze({
kind: "JSONPathLegNode",
type,
value
});
}
});
// server/node_modules/kysely/dist/query-builder/json-path-builder.js
var HASH_NEGATIVE_INDEX_REGEX = /^#-\d+$/;
class JSONPathBuilder {
#node;
constructor(node) {
this.#node = node;
}
at(index) {
if (typeof index !== "number" && typeof index !== "string" || typeof index === "number" && !Number.isInteger(index) || typeof index === "string" && index !== "last" && !HASH_NEGATIVE_INDEX_REGEX.test(index)) {
throw new Error(`Unexpected index value in .at(...): ${index}`);
}
return this.#createBuilderWithPathLeg("ArrayLocation", index);
}
key(key) {
return this.#createBuilderWithPathLeg("Member", key);
}
#createBuilderWithPathLeg(legType, value) {
if (JSONReferenceNode.is(this.#node)) {
return new TraversedJSONPathBuilder(JSONReferenceNode.cloneWithTraversal(this.#node, JSONPathNode.is(this.#node.traversal) ? JSONPathNode.cloneWithLeg(this.#node.traversal, JSONPathLegNode.create(legType, value)) : JSONOperatorChainNode.cloneWithValue(this.#node.traversal, ValueNode.createImmediate(value))));
}
return new TraversedJSONPathBuilder(JSONPathNode.cloneWithLeg(this.#node, JSONPathLegNode.create(legType, value)));
}
}
class TraversedJSONPathBuilder extends JSONPathBuilder {
#node;
constructor(node) {
super(node);
this.#node = node;
}
get expressionType() {
return;
}
as(alias) {
return new AliasedJSONPathBuilder(this, alias);
}
$castTo() {
return new TraversedJSONPathBuilder(this.#node);
}
$notNull() {
return new TraversedJSONPathBuilder(this.#node);
}
toOperationNode() {
return this.#node;
}
}
class AliasedJSONPathBuilder {
#jsonPath;
#alias;
constructor(jsonPath, alias) {
this.#jsonPath = jsonPath;
this.#alias = alias;
}
get expression() {
return this.#jsonPath;
}
get alias() {
return this.#alias;
}
toOperationNode() {
return AliasNode.create(this.#jsonPath.toOperationNode(), isOperationNodeSource(this.#alias) ? this.#alias.toOperationNode() : IdentifierNode.create(this.#alias));
}
}
// server/node_modules/kysely/dist/operation-node/tuple-node.js
var TupleNode = freeze({
is(node) {
return node.kind === "TupleNode";
},
create(values) {
return freeze({
kind: "TupleNode",
values: freeze(values)
});
}
});
// server/node_modules/kysely/dist/operation-node/data-type-node.js
var SIMPLE_COLUMN_DATA_TYPES = freeze({
bigint: true,
bigserial: true,
binary: true,
blob: true,
boolean: true,
bytea: true,
char: true,
date: true,
datemultirange: true,
daterange: true,
datetime: true,
datetime2: true,
decimal: true,
"double precision": true,
float4: true,
float8: true,
int2: true,
int4: true,
int4multirange: true,
int4range: true,
int8: true,
int8multirange: true,
int8range: true,
integer: true,
json: true,
jsonb: true,
numeric: true,
nummultirange: true,
numrange: true,
real: true,
serial: true,
smallint: true,
text: true,
time: true,
timestamp: true,
timestamptz: true,
timetz: true,
tsmultirange: true,
tsrange: true,
tstzmultirange: true,
tstzrange: true,
uuid: true,
varbinary: true,
varchar: true
});
var COLUMN_DATA_TYPE_REGEX = freeze([
/^varchar\(\d+\)$/,
/^char\(\d+\)$/,
/^decimal\(\d+, \d+\)$/,
/^numeric\(\d+, \d+\)$/,
/^binary\(\d+\)$/,
/^datetime\(\d+\)$/,
/^time\(\d+\)$/,
/^timetz\(\d+\)$/,
/^timestamp\(\d+\)$/,
/^timestamptz\(\d+\)$/,
/^datetime2\(\d+\)$/,
/^varbinary\(\d+\)$/
]);
var DataTypeNode = freeze({
is(node) {
return node.kind === "DataTypeNode";
},
create(dataType) {
return freeze({
kind: "DataTypeNode",
dataType
});
}
});
function isColumnDataType(dataType) {
return SIMPLE_COLUMN_DATA_TYPES[dataType] || COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType));
}
// server/node_modules/kysely/dist/parser/data-type-parser.js
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)}`);
}
// server/node_modules/kysely/dist/operation-node/cast-node.js
var CastNode = freeze({
is(node) {
return node.kind === "CastNode";
},
create(expression, dataType) {
return freeze({
kind: "CastNode",
expression,
dataType
});
}
});
// server/node_modules/kysely/dist/expression/expression-builder.js
function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
function binary(lhs, op, rhs) {
return new ExpressionWrapper(parseValueBinaryOperation(lhs, op, rhs));
}
function unary(op, expr) {
return new ExpressionWrapper(parseUnaryOperation(op, expr));
}
const eb = Object.assign(binary, {
fn: undefined,
eb: undefined,
selectFrom(table) {
return createSelectQueryBuilder({
queryId: createQueryId(),
executor,
queryNode: SelectQueryNode.createFrom(parseTableExpressionOrList(table))
});
},
case(reference) {
return new CaseBuilder({
node: CaseNode.create(isUndefined(reference) ? undefined : parseReferenceExpression(reference))
});
},
ref(reference, op) {
if (isUndefined(op)) {
return new ExpressionWrapper(parseStringReference(reference));
}
return new JSONPathBuilder(parseJSONReference(reference, op));
},
jsonPath() {
return new JSONPathBuilder(JSONPathNode.create());
},
table(table) {
return new ExpressionWrapper(parseTable(table));
},
val(value) {
return new ExpressionWrapper(parseValueExpression(value));
},
refTuple(...values) {
return new ExpressionWrapper(TupleNode.create(values.map(parseReferenceExpression)));
},
tuple(...values) {
return new ExpressionWrapper(TupleNode.create(values.map(parseValueExpression)));
},
lit(value) {
return new ExpressionWrapper(parseSafeImmediateValue(value));
},
unary,
not(expr) {
return unary("not", expr);
},
exists(expr) {
return unary("exists", expr);
},
neg(expr) {
return unary("-", expr);
},
between(expr, start, end) {
return new ExpressionWrapper(BinaryOperationNode.create(parseReferenceExpression(expr), OperatorNode.create("between"), AndNode.create(parseValueExpression(start), parseValueExpression(end))));
},
betweenSymmetric(expr, start, end) {
return new ExpressionWrapper(BinaryOperationNode.create(parseReferenceExpression(expr), OperatorNode.create("between symmetric"), AndNode.create(parseValueExpression(start), parseValueExpression(end))));
},
and(exprs) {
if (isReadonlyArray(exprs)) {
return new ExpressionWrapper(parseFilterList(exprs, "and"));
}
return new ExpressionWrapper(parseFilterObject(exprs, "and"));
},
or(exprs) {
if (isReadonlyArray(exprs)) {
return new ExpressionWrapper(parseFilterList(exprs, "or"));
}
return new ExpressionWrapper(parseFilterObject(exprs, "or"));
},
parens(...args) {
const node = parseValueBinaryOperationOrExpression(args);
if (ParensNode.is(node)) {
return new ExpressionWrapper(node);
} else {
return new ExpressionWrapper(ParensNode.create(node));
}
},
cast(expr, dataType) {
return new ExpressionWrapper(CastNode.create(parseReferenceExpression(expr), parseDataTypeExpression(dataType)));
}
});
eb.fn = createFunctionModule();
eb.eb = eb;
return eb;
}
function expressionBuilder(_) {
return createExpressionBuilder();
}
// server/node_modules/kysely/dist/parser/expression-parser.js
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)}`);
}
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)}`);
}
function isExpressionOrFactory(obj) {
return isExpression(obj) || isAliasedExpression(obj) || isFunction(obj);
}
// server/node_modules/kysely/dist/dynamic/dynamic-table-builder.js
class DynamicTableBuilder {
#table;
get table() {
return this.#table;
}
constructor(table) {
this.#table = table;
}
as(alias) {
return new AliasedDynamicTableBuilder(this.#table, alias);
}
}
class AliasedDynamicTableBuilder {
#table;
#alias;
get table() {
return this.#table;
}
get alias() {
return this.#alias;
}
constructor(table, alias) {
this.#table = table;
this.#alias = alias;
}
toOperationNode() {
return AliasNode.create(parseTable(this.#table), IdentifierNode.create(this.#alias));
}
}
function isAliasedDynamicTableBuilder(obj) {
return isObject(obj) && isOperationNodeSource(obj) && isString(obj.table) && isString(obj.alias);
}
// server/node_modules/kysely/dist/parser/table-parser.js
function parseTableExpressionOrList(table) {
if (isReadonlyArray(table)) {
return table.map((it) => parseTableExpression(it));
} else {
return [parseTableExpression(table)];
}
}
function parseTableExpression(table) {
if (isString(table)) {
return parseAliasedTable(table);
} else if (isAliasedDynamicTableBuilder(table)) {
return table.toOperationNode();
} else {
return parseAliasedExpression(table);
}
}
function parseAliasedTable(from) {
const ALIAS_SEPARATOR = " as ";
if (from.includes(ALIAS_SEPARATOR)) {
const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim2);
return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
} else {
return parseTable(from);
}
}
function parseTable(from) {
const SCHEMA_SEPARATOR = ".";
if (from.includes(SCHEMA_SEPARATOR)) {
const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim2);
return TableNode.createWithSchema(schema, table);
} else {
return TableNode.create(from);
}
}
function trim2(str) {
return str.trim();
}
// server/node_modules/kysely/dist/operation-node/add-column-node.js
var AddColumnNode = freeze({
is(node) {
return node.kind === "AddColumnNode";
},
create(column) {
return freeze({
kind: "AddColumnNode",
column
});
}
});
// server/node_modules/kysely/dist/operation-node/column-definition-node.js
var ColumnDefinitionNode = freeze({
is(node) {
return node.kind === "ColumnDefinitionNode";
},
create(column, dataType) {
return freeze({
kind: "ColumnDefinitionNode",
column: ColumnNode.create(column),
dataType
});
},
cloneWithFrontModifier(node, modifier) {
return freeze({
...node,
frontModifiers: node.frontModifiers ? freeze([...node.frontModifiers, modifier]) : [modifier]
});
},
cloneWithEndModifier(node, modifier) {
return freeze({
...node,
endModifiers: node.endModifiers ? freeze([...node.endModifiers, modifier]) : [modifier]
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/drop-column-node.js
var DropColumnNode = freeze({
is(node) {
return node.kind === "DropColumnNode";
},
create(column) {
return freeze({
kind: "DropColumnNode",
column: ColumnNode.create(column)
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/rename-column-node.js
var RenameColumnNode = freeze({
is(node) {
return node.kind === "RenameColumnNode";
},
create(column, newColumn) {
return freeze({
kind: "RenameColumnNode",
column: ColumnNode.create(column),
renameTo: ColumnNode.create(newColumn)
});
}
});
// server/node_modules/kysely/dist/operation-node/check-constraint-node.js
var CheckConstraintNode = freeze({
is(node) {
return node.kind === "CheckConstraintNode";
},
create(expression, constraintName) {
return freeze({
kind: "CheckConstraintNode",
expression,
name: constraintName ? IdentifierNode.create(constraintName) : undefined
});
}
});
// server/node_modules/kysely/dist/operation-node/references-node.js
var ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY = freeze({
cascade: true,
"no action": true,
restrict: true,
"set default": true,
"set null": true
});
var ON_MODIFY_FOREIGN_ACTIONS = Object.keys(ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY);
var ReferencesNode = freeze({
is(node) {
return node.kind === "ReferencesNode";
},
create(table, columns) {
return freeze({
kind: "ReferencesNode",
table,
columns: freeze([...columns])
});
},
cloneWithOnDelete(references, onDelete) {
return freeze({
...references,
onDelete
});
},
cloneWithOnUpdate(references, onUpdate) {
return freeze({
...references,
onUpdate
});
}
});
function isOnModifyForeignAction(thing) {
return isString(thing) && ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY[thing];
}
// server/node_modules/kysely/dist/parser/default-value-parser.js
function parseDefaultValueExpression(value) {
return isOperationNodeSource(value) ? value.toOperationNode() : ValueNode.createImmediate(value);
}
// server/node_modules/kysely/dist/operation-node/generated-node.js
var GeneratedNode = freeze({
is(node) {
return node.kind === "GeneratedNode";
},
create(params) {
return freeze({
kind: "GeneratedNode",
...params
});
},
createWithExpression(expression) {
return freeze({
kind: "GeneratedNode",
always: true,
expression
});
},
cloneWith(node, params) {
return freeze({
...node,
...params
});
}
});
// server/node_modules/kysely/dist/operation-node/default-value-node.js
var DefaultValueNode = freeze({
is(node) {
return node.kind === "DefaultValueNode";
},
create(defaultValue) {
return freeze({
kind: "DefaultValueNode",
defaultValue
});
}
});
// server/node_modules/kysely/dist/parser/on-modify-action-parser.js
function parseOnModifyForeignAction(action) {
if (isOnModifyForeignAction(action)) {
return action;
}
throw new Error(`invalid OnModifyForeignAction ${action}`);
}
// server/node_modules/kysely/dist/schema/column-definition-builder.js
class ColumnDefinitionBuilder {
#node;
constructor(node) {
this.#node = node;
}
autoIncrement() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
}
identity() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { identity: true }));
}
primaryKey() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));
}
references(ref) {
const references = parseStringReference(ref);
if (!references.table || SelectAllNode.is(references.column)) {
throw new Error(`invalid call references('${ref}'). The reference must have format table.column or schema.table.column`);
}
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
references: ReferencesNode.create(references.table, [
references.column
])
}));
}
onDelete(onDelete) {
if (!this.#node.references) {
throw new Error("on delete constraint can only be added for foreign keys");
}
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
references: ReferencesNode.cloneWithOnDelete(this.#node.references, parseOnModifyForeignAction(onDelete))
}));
}
onUpdate(onUpdate) {
if (!this.#node.references) {
throw new Error("on update constraint can only be added for foreign keys");
}
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
references: ReferencesNode.cloneWithOnUpdate(this.#node.references, parseOnModifyForeignAction(onUpdate))
}));
}
unique() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
}
notNull() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
}
unsigned() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
}
defaultTo(value) {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value))
}));
}
check(expression) {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
check: CheckConstraintNode.create(expression.toOperationNode())
}));
}
generatedAlwaysAs(expression) {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
generated: GeneratedNode.createWithExpression(expression.toOperationNode())
}));
}
generatedAlwaysAsIdentity() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
generated: GeneratedNode.create({ identity: true, always: true })
}));
}
generatedByDefaultAsIdentity() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
generated: GeneratedNode.create({ identity: true, byDefault: true })
}));
}
stored() {
if (!this.#node.generated) {
throw new Error("stored() can only be called after generatedAlwaysAs");
}
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
generated: GeneratedNode.cloneWith(this.#node.generated, {
stored: true
})
}));
}
modifyFront(modifier) {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWithFrontModifier(this.#node, modifier.toOperationNode()));
}
nullsNotDistinct() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { nullsNotDistinct: true }));
}
ifNotExists() {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { ifNotExists: true }));
}
modifyEnd(modifier) {
return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWithEndModifier(this.#node, modifier.toOperationNode()));
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/operation-node/modify-column-node.js
var ModifyColumnNode = freeze({
is(node) {
return node.kind === "ModifyColumnNode";
},
create(column) {
return freeze({
kind: "ModifyColumnNode",
column
});
}
});
// server/node_modules/kysely/dist/operation-node/foreign-key-constraint-node.js
var ForeignKeyConstraintNode = freeze({
is(node) {
return node.kind === "ForeignKeyConstraintNode";
},
create(sourceColumns, targetTable, targetColumns, constraintName) {
return freeze({
kind: "ForeignKeyConstraintNode",
columns: sourceColumns,
references: ReferencesNode.create(targetTable, targetColumns),
name: constraintName ? IdentifierNode.create(constraintName) : undefined
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/schema/foreign-key-constraint-builder.js
class ForeignKeyConstraintBuilder {
#node;
constructor(node) {
this.#node = node;
}
onDelete(onDelete) {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
onDelete: parseOnModifyForeignAction(onDelete)
}));
}
onUpdate(onUpdate) {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
onUpdate: parseOnModifyForeignAction(onUpdate)
}));
}
deferrable() {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, { deferrable: true }));
}
notDeferrable() {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, { deferrable: false }));
}
initiallyDeferred() {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
initiallyDeferred: true
}));
}
initiallyImmediate() {
return new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.cloneWith(this.#node, {
initiallyDeferred: false
}));
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/operation-node/add-constraint-node.js
var AddConstraintNode = freeze({
is(node) {
return node.kind === "AddConstraintNode";
},
create(constraint) {
return freeze({
kind: "AddConstraintNode",
constraint
});
}
});
// server/node_modules/kysely/dist/operation-node/unique-constraint-node.js
var UniqueConstraintNode = freeze({
is(node) {
return node.kind === "UniqueConstraintNode";
},
create(columns, constraintName, nullsNotDistinct) {
if (isString(columns.at(0))) {
logOnce("`UniqueConstraintNode.create(columns: string[], ...)` is deprecated - pass `ColumnNode[]` instead.");
columns = columns.map(ColumnNode.create);
}
return freeze({
kind: "UniqueConstraintNode",
columns: freeze(columns),
name: constraintName ? IdentifierNode.create(constraintName) : undefined,
nullsNotDistinct
});
},
cloneWith(node, props) {
return freeze({ ...node, ...props });
}
});
// server/node_modules/kysely/dist/operation-node/drop-constraint-node.js
var DropConstraintNode = freeze({
is(node) {
return node.kind === "DropConstraintNode";
},
create(constraintName) {
return freeze({
kind: "DropConstraintNode",
constraintName: IdentifierNode.create(constraintName)
});
},
cloneWith(dropConstraint, props) {
return freeze({
...dropConstraint,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/alter-column-node.js
var AlterColumnNode = freeze({
is(node) {
return node.kind === "AlterColumnNode";
},
create(column, prop, value) {
return freeze({
kind: "AlterColumnNode",
column: ColumnNode.create(column),
[prop]: value
});
}
});
// server/node_modules/kysely/dist/schema/alter-column-builder.js
class AlterColumnBuilder {
#column;
constructor(column) {
this.#column = column;
}
setDataType(dataType) {
return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, "dataType", parseDataTypeExpression(dataType)));
}
setDefault(value) {
return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, "setDefault", parseDefaultValueExpression(value)));
}
dropDefault() {
return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, "dropDefault", true));
}
setNotNull() {
return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, "setNotNull", true));
}
dropNotNull() {
return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, "dropNotNull", true));
}
$call(func) {
return func(this);
}
}
class AlteredColumnBuilder {
#alterColumnNode;
constructor(alterColumnNode) {
this.#alterColumnNode = alterColumnNode;
}
toOperationNode() {
return this.#alterColumnNode;
}
}
// server/node_modules/kysely/dist/schema/alter-table-executor.js
class AlterTableExecutor {
#props;
constructor(props) {
this.#props = freeze(props);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/alter-table-add-foreign-key-constraint-builder.js
class AlterTableAddForeignKeyConstraintBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
onDelete(onDelete) {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete)
});
}
onUpdate(onUpdate) {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate)
});
}
deferrable() {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.deferrable()
});
}
notDeferrable() {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.notDeferrable()
});
}
initiallyDeferred() {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.initiallyDeferred()
});
}
initiallyImmediate() {
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder: this.#props.constraintBuilder.initiallyImmediate()
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(AlterTableNode.cloneWithTableProps(this.#props.node, {
addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode())
}), this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/alter-table-drop-constraint-builder.js
class AlterTableDropConstraintBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
ifExists() {
return new AlterTableDropConstraintBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
ifExists: true
})
})
});
}
cascade() {
return new AlterTableDropConstraintBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
modifier: "cascade"
})
})
});
}
restrict() {
return new AlterTableDropConstraintBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
dropConstraint: DropConstraintNode.cloneWith(this.#props.node.dropConstraint, {
modifier: "restrict"
})
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/primary-key-constraint-node.js
var PrimaryKeyConstraintNode = freeze({
is(node) {
return node.kind === "PrimaryKeyConstraintNode";
},
create(columns, constraintName) {
return freeze({
kind: "PrimaryKeyConstraintNode",
columns: freeze(columns.map(ColumnNode.create)),
name: constraintName ? IdentifierNode.create(constraintName) : undefined
});
},
cloneWith(node, props) {
return freeze({ ...node, ...props });
}
});
// server/node_modules/kysely/dist/operation-node/add-index-node.js
var AddIndexNode = freeze({
is(node) {
return node.kind === "AddIndexNode";
},
create(name) {
return freeze({
kind: "AddIndexNode",
name: IdentifierNode.create(name)
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
},
cloneWithColumns(node, columns) {
return freeze({
...node,
columns: [...node.columns || [], ...columns]
});
}
});
// server/node_modules/kysely/dist/schema/alter-table-add-index-builder.js
class AlterTableAddIndexBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
unique() {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
unique: true
})
})
});
}
column(arg) {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
isString(arg) ? parseOrderedColumnName(arg) : arg.toOperationNode()
])
})
});
}
columns(columns) {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, columns.map((item) => isString(item) ? parseOrderedColumnName(item) : item.toOperationNode()))
})
});
}
expression(expression) {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
expression.toOperationNode()
])
})
});
}
using(indexType) {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
using: RawNode.createWithSql(indexType)
})
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/unique-constraint-builder.js
class UniqueConstraintNodeBuilder {
#node;
constructor(node) {
this.#node = node;
}
nullsNotDistinct() {
return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { nullsNotDistinct: true }));
}
deferrable() {
return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { deferrable: true }));
}
notDeferrable() {
return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { deferrable: false }));
}
initiallyDeferred() {
return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, {
initiallyDeferred: true
}));
}
initiallyImmediate() {
return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, {
initiallyDeferred: false
}));
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/schema/primary-key-constraint-builder.js
class PrimaryKeyConstraintBuilder {
#node;
constructor(node) {
this.#node = node;
}
deferrable() {
return new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.cloneWith(this.#node, { deferrable: true }));
}
notDeferrable() {
return new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.cloneWith(this.#node, { deferrable: false }));
}
initiallyDeferred() {
return new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.cloneWith(this.#node, {
initiallyDeferred: true
}));
}
initiallyImmediate() {
return new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.cloneWith(this.#node, {
initiallyDeferred: false
}));
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/schema/check-constraint-builder.js
class CheckConstraintBuilder {
#node;
constructor(node) {
this.#node = node;
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/operation-node/rename-constraint-node.js
var RenameConstraintNode = freeze({
is(node) {
return node.kind === "RenameConstraintNode";
},
create(oldName, newName) {
return freeze({
kind: "RenameConstraintNode",
oldName: IdentifierNode.create(oldName),
newName: IdentifierNode.create(newName)
});
}
});
// server/node_modules/kysely/dist/schema/drop-column-builder.js
class DropColumnBuilder {
#props;
constructor(props) {
this.#props = freeze({ ...props });
}
ifExists() {
return new DropColumnBuilder({
...this.#props,
node: DropColumnNode.cloneWith(this.#props.node, { ifExists: true })
});
}
toOperationNode() {
return this.#props.node;
}
}
// server/node_modules/kysely/dist/schema/alter-table-builder.js
class AlterTableBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
renameTo(newTableName) {
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
renameTo: parseTable(newTableName)
})
});
}
setSchema(newSchema) {
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
setSchema: IdentifierNode.create(newSchema)
})
});
}
alterColumn(column, alteration) {
const builder = alteration(new AlterColumnBuilder(column));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode())
});
}
dropColumn(column, build = noop) {
const builder = build(new DropColumnBuilder({ node: DropColumnNode.create(column) }));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode())
});
}
renameColumn(column, newColumn) {
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, RenameColumnNode.create(column, newColumn))
});
}
addColumn(columnName, dataType, build = noop) {
const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, AddColumnNode.create(builder.toOperationNode()))
});
}
modifyColumn(columnName, dataType, build = noop) {
const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, ModifyColumnNode.create(builder.toOperationNode()))
});
}
addUniqueConstraint(constraintName, columns, build = noop) {
const uniqueConstraintBuilder = build(new UniqueConstraintNodeBuilder(UniqueConstraintNode.create(columns.map((column) => isString(column) ? ColumnNode.create(column) : parseExpression(column)), constraintName)));
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addConstraint: AddConstraintNode.create(uniqueConstraintBuilder.toOperationNode())
})
});
}
addCheckConstraint(constraintName, checkExpression, build = noop) {
const constraintBuilder = build(new CheckConstraintBuilder(CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)));
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addConstraint: AddConstraintNode.create(constraintBuilder.toOperationNode())
})
});
}
addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = noop) {
const constraintBuilder = build(new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)));
return new AlterTableAddForeignKeyConstraintBuilder({
...this.#props,
constraintBuilder
});
}
addPrimaryKeyConstraint(constraintName, columns, build = noop) {
const constraintBuilder = build(new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.create(columns, constraintName)));
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addConstraint: AddConstraintNode.create(constraintBuilder.toOperationNode())
})
});
}
dropConstraint(constraintName) {
return new AlterTableDropConstraintBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
dropConstraint: DropConstraintNode.create(constraintName)
})
});
}
renameConstraint(oldName, newName) {
return new AlterTableDropConstraintBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
renameConstraint: RenameConstraintNode.create(oldName, newName)
})
});
}
addIndex(indexName) {
return new AlterTableAddIndexBuilder({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
addIndex: AddIndexNode.create(indexName)
})
});
}
dropIndex(indexName) {
return new AlterTableExecutor({
...this.#props,
node: AlterTableNode.cloneWithTableProps(this.#props.node, {
dropIndex: DropIndexNode.create(indexName)
})
});
}
$call(func) {
return func(this);
}
}
class AlterTableColumnAlteringBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
alterColumn(column, alteration) {
const builder = alteration(new AlterColumnBuilder(column));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode())
});
}
dropColumn(column, build = noop) {
const builder = build(new DropColumnBuilder({ node: DropColumnNode.create(column) }));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, builder.toOperationNode())
});
}
renameColumn(column, newColumn) {
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, RenameColumnNode.create(column, newColumn))
});
}
addColumn(columnName, dataType, build = noop) {
const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, AddColumnNode.create(builder.toOperationNode()))
});
}
modifyColumn(columnName, dataType, build = noop) {
const builder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
return new AlterTableColumnAlteringBuilder({
...this.#props,
node: AlterTableNode.cloneWithColumnAlteration(this.#props.node, ModifyColumnNode.create(builder.toOperationNode()))
});
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/plugin/immediate-value/immediate-value-transformer.js
class ImmediateValueTransformer extends OperationNodeTransformer {
transformPrimitiveValueList(node) {
return ValueListNode.create(node.values.map(ValueNode.createImmediate));
}
transformValue(node) {
return ValueNode.createImmediate(node.value);
}
}
// server/node_modules/kysely/dist/schema/create-index-builder.js
class CreateIndexBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
ifNotExists() {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWith(this.#props.node, {
ifNotExists: true
})
});
}
unique() {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWith(this.#props.node, {
unique: true
})
});
}
nullsNotDistinct() {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWith(this.#props.node, {
nullsNotDistinct: true
})
});
}
on(table) {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWith(this.#props.node, {
table: parseTable(table)
})
});
}
column(arg) {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWithColumns(this.#props.node, [
isString(arg) ? parseOrderedColumnName(arg) : arg.toOperationNode()
])
});
}
columns(columns) {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWithColumns(this.#props.node, columns.map((item) => isString(item) ? parseOrderedColumnName(item) : item.toOperationNode()))
});
}
expression(expression) {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWithColumns(this.#props.node, [
expression.toOperationNode()
])
});
}
using(indexType) {
return new CreateIndexBuilder({
...this.#props,
node: CreateIndexNode.cloneWith(this.#props.node, {
using: RawNode.createWithSql(indexType)
})
});
}
where(...args) {
const transformer = new ImmediateValueTransformer;
return new CreateIndexBuilder({
...this.#props,
node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseValueBinaryOperationOrExpression(args), this.#props.queryId))
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/create-schema-builder.js
class CreateSchemaBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
ifNotExists() {
return new CreateSchemaBuilder({
...this.#props,
node: CreateSchemaNode.cloneWith(this.#props.node, { ifNotExists: true })
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/parser/on-commit-action-parse.js
function parseOnCommitAction(action) {
if (ON_COMMIT_ACTIONS.includes(action)) {
return action;
}
throw new Error(`invalid OnCommitAction ${action}`);
}
// server/node_modules/kysely/dist/schema/create-table-add-index-builder.js
class CreateTableAddIndexBuilder {
#node;
constructor(node) {
this.#node = node;
}
using(indexType) {
return new CreateTableAddIndexBuilder(AddIndexNode.cloneWith(this.#node, {
using: RawNode.createWithSql(indexType)
}));
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#node;
}
}
// server/node_modules/kysely/dist/schema/create-table-builder.js
class CreateTableBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
temporary() {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWith(this.#props.node, {
temporary: true
})
});
}
onCommit(onCommit) {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWith(this.#props.node, {
onCommit: parseOnCommitAction(onCommit)
})
});
}
ifNotExists() {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWith(this.#props.node, {
ifNotExists: true
})
});
}
addColumn(columnName, dataType, build = noop) {
const columnBuilder = build(new ColumnDefinitionBuilder(ColumnDefinitionNode.create(columnName, parseDataTypeExpression(dataType))));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithColumn(this.#props.node, columnBuilder.toOperationNode())
});
}
addPrimaryKeyConstraint(constraintName, columns, build = noop) {
const constraintBuilder = build(new PrimaryKeyConstraintBuilder(PrimaryKeyConstraintNode.create(columns, constraintName)));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithConstraint(this.#props.node, constraintBuilder.toOperationNode())
});
}
addUniqueConstraint(constraintName, columns, build = noop) {
const uniqueConstraintBuilder = build(new UniqueConstraintNodeBuilder(UniqueConstraintNode.create(columns.map((column) => isString(column) ? ColumnNode.create(column) : parseExpression(column)), constraintName)));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithConstraint(this.#props.node, uniqueConstraintBuilder.toOperationNode())
});
}
addIndex(indexName, columns, build = noop) {
const addIndexBuilder = build(new CreateTableAddIndexBuilder(AddIndexNode.cloneWithColumns(AddIndexNode.create(indexName), columns.map((column) => isString(column) ? ColumnNode.create(column) : parseExpression(column)))));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithIndex(this.#props.node, addIndexBuilder.toOperationNode())
});
}
addCheckConstraint(constraintName, checkExpression, build = noop) {
const constraintBuilder = build(new CheckConstraintBuilder(CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithConstraint(this.#props.node, constraintBuilder.toOperationNode())
});
}
addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = noop) {
const builder = build(new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)));
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithConstraint(this.#props.node, builder.toOperationNode())
});
}
modifyFront(modifier) {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithFrontModifier(this.#props.node, modifier.toOperationNode())
});
}
modifyEnd(modifier) {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWithEndModifier(this.#props.node, modifier.toOperationNode())
});
}
as(expression) {
return new CreateTableBuilder({
...this.#props,
node: CreateTableNode.cloneWith(this.#props.node, {
selectQuery: parseExpression(expression)
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/drop-index-builder.js
class DropIndexBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
on(table) {
return new DropIndexBuilder({
...this.#props,
node: DropIndexNode.cloneWith(this.#props.node, {
table: parseTable(table)
})
});
}
ifExists() {
return new DropIndexBuilder({
...this.#props,
node: DropIndexNode.cloneWith(this.#props.node, {
ifExists: true
})
});
}
cascade() {
return new DropIndexBuilder({
...this.#props,
node: DropIndexNode.cloneWith(this.#props.node, {
cascade: true
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/drop-schema-builder.js
class DropSchemaBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
ifExists() {
return new DropSchemaBuilder({
...this.#props,
node: DropSchemaNode.cloneWith(this.#props.node, {
ifExists: true
})
});
}
cascade() {
return new DropSchemaBuilder({
...this.#props,
node: DropSchemaNode.cloneWith(this.#props.node, {
cascade: true
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/drop-table-builder.js
class DropTableBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
temporary() {
return new DropTableBuilder({
...this.#props,
node: DropTableNode.cloneWith(this.#props.node, {
temporary: true
})
});
}
ifExists() {
return new DropTableBuilder({
...this.#props,
node: DropTableNode.cloneWith(this.#props.node, {
ifExists: true
})
});
}
cascade() {
return new DropTableBuilder({
...this.#props,
node: DropTableNode.cloneWith(this.#props.node, {
cascade: true
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/create-view-node.js
var CreateViewNode = freeze({
is(node) {
return node.kind === "CreateViewNode";
},
create(name) {
return freeze({
kind: "CreateViewNode",
name: SchemableIdentifierNode.create(name)
});
},
cloneWith(createView, params) {
return freeze({
...createView,
...params
});
}
});
// server/node_modules/kysely/dist/plugin/immediate-value/immediate-value-plugin.js
class ImmediateValuePlugin {
#transformer = new ImmediateValueTransformer;
transformQuery(args) {
return this.#transformer.transformNode(args.node, args.queryId);
}
transformResult(args) {
return Promise.resolve(args.result);
}
}
// server/node_modules/kysely/dist/schema/create-view-builder.js
class CreateViewBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
temporary() {
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
temporary: true
})
});
}
materialized() {
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
materialized: true
})
});
}
ifNotExists() {
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
ifNotExists: true
})
});
}
orReplace() {
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
orReplace: true
})
});
}
columns(columns) {
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
columns: columns.map(parseColumnName)
})
});
}
as(query) {
const queryNode = query.withPlugin(new ImmediateValuePlugin).toOperationNode();
return new CreateViewBuilder({
...this.#props,
node: CreateViewNode.cloneWith(this.#props.node, {
as: queryNode
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/drop-view-node.js
var DropViewNode = freeze({
is(node) {
return node.kind === "DropViewNode";
},
create(name) {
return freeze({
kind: "DropViewNode",
name: SchemableIdentifierNode.create(name)
});
},
cloneWith(dropView, params) {
return freeze({
...dropView,
...params
});
}
});
// server/node_modules/kysely/dist/schema/drop-view-builder.js
class DropViewBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
materialized() {
return new DropViewBuilder({
...this.#props,
node: DropViewNode.cloneWith(this.#props.node, {
materialized: true
})
});
}
ifExists() {
return new DropViewBuilder({
...this.#props,
node: DropViewNode.cloneWith(this.#props.node, {
ifExists: true
})
});
}
cascade() {
return new DropViewBuilder({
...this.#props,
node: DropViewNode.cloneWith(this.#props.node, {
cascade: true
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/create-type-node.js
var CreateTypeNode = freeze({
is(node) {
return node.kind === "CreateTypeNode";
},
create(name) {
return freeze({
kind: "CreateTypeNode",
name
});
},
cloneWithEnum(createType, values) {
return freeze({
...createType,
enum: ValueListNode.create(values.map(ValueNode.createImmediate))
});
}
});
// server/node_modules/kysely/dist/schema/create-type-builder.js
class CreateTypeBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
asEnum(values) {
return new CreateTypeBuilder({
...this.#props,
node: CreateTypeNode.cloneWithEnum(this.#props.node, values)
});
}
$call(func) {
return func(this);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/drop-type-node.js
var DropTypeNode = freeze({
is(node) {
return node.kind === "DropTypeNode";
},
create(names) {
if (!Array.isArray(names)) {
names = [names];
}
return freeze({
kind: "DropTypeNode",
name: names[0],
additionalNames: names.slice(1)
});
},
cloneWith(dropType, params) {
return freeze({
...dropType,
...params
});
}
});
// server/node_modules/kysely/dist/schema/drop-type-builder.js
class DropTypeBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
ifExists() {
return new DropTypeBuilder({
...this.#props,
node: DropTypeNode.cloneWith(this.#props.node, {
ifExists: true
})
});
}
cascade() {
return new DropTypeBuilder({
...this.#props,
node: DropTypeNode.cloneWith(this.#props.node, {
cascade: true
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/parser/identifier-parser.js
function parseSchemableIdentifier(id) {
const SCHEMA_SEPARATOR = ".";
if (id.includes(SCHEMA_SEPARATOR)) {
const parts = id.split(SCHEMA_SEPARATOR).map(trim3);
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 parseSchemableIdentifierArray(id) {
if (!Array.isArray(id)) {
id = [id];
}
return id.map(parseSchemableIdentifier);
}
function trim3(str) {
return str.trim();
}
// server/node_modules/kysely/dist/operation-node/refresh-materialized-view-node.js
var RefreshMaterializedViewNode = freeze({
is(node) {
return node.kind === "RefreshMaterializedViewNode";
},
create(name) {
return freeze({
kind: "RefreshMaterializedViewNode",
name: SchemableIdentifierNode.create(name)
});
},
cloneWith(createView, params) {
return freeze({
...createView,
...params
});
}
});
// server/node_modules/kysely/dist/schema/refresh-materialized-view-builder.js
class RefreshMaterializedViewBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
concurrently() {
return new RefreshMaterializedViewBuilder({
...this.#props,
node: RefreshMaterializedViewNode.cloneWith(this.#props.node, {
concurrently: true,
withNoData: false
})
});
}
withData() {
return new RefreshMaterializedViewBuilder({
...this.#props,
node: RefreshMaterializedViewNode.cloneWith(this.#props.node, {
withNoData: false
})
});
}
withNoData() {
return new RefreshMaterializedViewBuilder({
...this.#props,
node: RefreshMaterializedViewNode.cloneWith(this.#props.node, {
withNoData: true,
concurrently: false
})
});
}
$call(func) {
return func(this);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/operation-node/alter-type-node.js
var AlterTypeNode = freeze({
is(node) {
return node.kind === "AlterTypeNode";
},
create(name) {
return freeze({
kind: "AlterTypeNode",
name
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/operation-node/add-value-node.js
var AddValueNode = freeze({
is(node) {
return node.kind === "AddValueNode";
},
create(value) {
return freeze({
kind: "AddValueNode",
value
});
},
cloneWith(node, props) {
return freeze({
...node,
...props
});
}
});
// server/node_modules/kysely/dist/query-finalizer.js
class QueryFinalizer {
#props;
constructor(props) {
this.#props = freeze(props);
}
toOperationNode() {
return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
}
compile() {
return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
}
async execute(options) {
return await this.#props.executor.executeQuery(this.compile(), options);
}
}
// server/node_modules/kysely/dist/schema/alter-type-add-value-builder.js
var _a4;
class AlterTypeAddValueBuilder extends QueryFinalizer {
#props;
constructor(props) {
super(props);
this.#props = props;
}
ifNotExists() {
return new _a4({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
addValue: AddValueNode.cloneWith(this.#props.node.addValue, {
ifNotExists: true
})
})
});
}
before(neighborValue) {
return this.#setNeighbor(neighborValue, true);
}
after(neighborValue) {
return this.#setNeighbor(neighborValue, false);
}
#setNeighbor(neighborValue, isBefore) {
return new _a4({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
addValue: AddValueNode.cloneWith(this.#props.node.addValue, {
isBefore,
neighborValue: ValueNode.createImmediate(neighborValue)
})
})
});
}
}
_a4 = AlterTypeAddValueBuilder;
// server/node_modules/kysely/dist/operation-node/rename-value-node.js
var RenameValueNode = freeze({
is(node) {
return node.kind === "RenameValueNode";
},
create(oldValue, newValue) {
return freeze({
kind: "RenameValueNode",
oldValue,
newValue
});
}
});
// server/node_modules/kysely/dist/schema/alter-type-builder.js
class AlterTypeBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
addValue(value) {
return new AlterTypeAddValueBuilder({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
addValue: AddValueNode.create(ValueNode.createImmediate(value))
})
});
}
renameTo(newName) {
return new QueryFinalizer({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
renameTo: IdentifierNode.create(newName)
})
});
}
renameValue(oldValue, newValue) {
return new QueryFinalizer({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
renameValue: RenameValueNode.create(ValueNode.createImmediate(oldValue), ValueNode.createImmediate(newValue))
})
});
}
setSchema(schema) {
return new QueryFinalizer({
...this.#props,
node: AlterTypeNode.cloneWith(this.#props.node, {
setSchema: IdentifierNode.create(schema)
})
});
}
}
// server/node_modules/kysely/dist/schema/schema-module.js
class SchemaModule {
#executor;
constructor(executor) {
this.#executor = executor;
}
createTable(table) {
return new CreateTableBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: CreateTableNode.create(parseTable(table))
});
}
dropTable(table) {
return new DropTableBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: DropTableNode.create(parseTable(table))
});
}
createIndex(indexName) {
return new CreateIndexBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: CreateIndexNode.create(indexName)
});
}
dropIndex(indexName) {
return new DropIndexBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: DropIndexNode.create(indexName)
});
}
createSchema(schema) {
return new CreateSchemaBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: CreateSchemaNode.create(schema)
});
}
dropSchema(schema) {
return new DropSchemaBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: DropSchemaNode.create(schema)
});
}
alterTable(table) {
return new AlterTableBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: AlterTableNode.create(parseTable(table))
});
}
createView(viewName) {
return new CreateViewBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: CreateViewNode.create(viewName)
});
}
refreshMaterializedView(viewName) {
return new RefreshMaterializedViewBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: RefreshMaterializedViewNode.create(viewName)
});
}
dropView(viewName) {
return new DropViewBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: DropViewNode.create(viewName)
});
}
createType(typeName) {
return new CreateTypeBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: CreateTypeNode.create(parseSchemableIdentifier(typeName))
});
}
alterType(name) {
return new AlterTypeBuilder({
executor: this.#executor,
node: AlterTypeNode.create(parseSchemableIdentifier(name)),
queryId: createQueryId()
});
}
dropType(typeName) {
return new DropTypeBuilder({
queryId: createQueryId(),
executor: this.#executor,
node: DropTypeNode.create(parseSchemableIdentifierArray(typeName))
});
}
withPlugin(plugin) {
return new SchemaModule(this.#executor.withPlugin(plugin));
}
withoutPlugins() {
return new SchemaModule(this.#executor.withoutPlugins());
}
withSchema(schema) {
return new SchemaModule(this.#executor.withPluginAtFront(new WithSchemaPlugin(schema)));
}
}
// server/node_modules/kysely/dist/dynamic/dynamic.js
class DynamicModule {
ref(reference) {
return new DynamicReferenceBuilder(reference);
}
table(table) {
return new DynamicTableBuilder(table);
}
}
// server/node_modules/kysely/dist/driver/default-connection-provider.js
class DefaultConnectionProvider {
#driver;
constructor(driver) {
this.#driver = driver;
}
async provideConnection(consumer, options) {
const connection = await this.#driver.acquireConnection(options);
try {
return await consumer(connection);
} finally {
await this.#driver.releaseConnection(connection, options);
}
}
}
// server/node_modules/kysely/dist/query-executor/default-query-executor.js
class DefaultQueryExecutor extends QueryExecutorBase {
#compiler;
#adapter;
#connectionProvider;
constructor(compiler, adapter, connectionProvider, plugins = []) {
super(plugins);
this.#compiler = compiler;
this.#adapter = adapter;
this.#connectionProvider = connectionProvider;
}
get adapter() {
return this.#adapter;
}
compileQuery(node, queryId) {
return this.#compiler.compileQuery(node, queryId);
}
provideConnection(consumer, options) {
return this.#connectionProvider.provideConnection(consumer, options);
}
withPlugins(plugins) {
return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, ...plugins]);
}
withPlugin(plugin) {
return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, plugin]);
}
withPluginAtFront(plugin) {
return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [plugin, ...this.plugins]);
}
withConnectionProvider(connectionProvider) {
return new DefaultQueryExecutor(this.#compiler, this.#adapter, connectionProvider, [...this.plugins]);
}
withoutPlugins() {
return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, []);
}
}
// server/node_modules/kysely/dist/util/performance-now.js
function performanceNow() {
if (typeof performance !== "undefined" && isFunction(performance.now)) {
return performance.now();
} else {
return Date.now();
}
}
// server/node_modules/kysely/dist/driver/connection-mutex.js
class ConnectionMutex {
#promise;
#resolve;
async obtainLock() {
while (this.#promise) {
await this.#promise;
}
this.#promise = new Promise((resolve) => {
this.#resolve = resolve;
});
}
releaseLock() {
const resolve = this.#resolve;
this.#promise = undefined;
this.#resolve = undefined;
resolve?.();
}
}
// server/node_modules/kysely/dist/driver/runtime-driver.js
class RuntimeDriver {
#driver;
#log;
#initPromise;
#initDone;
#destroyPromise;
#connections = new WeakSet;
#connectionMutex;
constructor(driver, adapter, log) {
this.#driver = driver;
this.#initDone = false;
this.#log = log;
if (adapter.supportsMultipleConnections === false) {
this.#connectionMutex = new ConnectionMutex;
}
}
async init(options) {
if (this.#destroyPromise) {
throw new Error("driver has already been destroyed");
}
this.#initPromise ??= this.#driver.init(options).then(() => {
this.#initDone = true;
}).catch((reason) => {
this.#initPromise = undefined;
throw reason;
});
await waitOrAbort(this.#initPromise, options?.signal, "init");
}
async acquireConnection(options) {
if (this.#destroyPromise) {
throw new Error("driver has already been destroyed");
}
if (!this.#initDone) {
await this.init(options);
}
if (this.#connectionMutex) {
const lockPromise = this.#connectionMutex.obtainLock();
await waitOrAbort(lockPromise, options?.signal, "acquireConnection:mutex", () => lockPromise.then(() => this.#connectionMutex?.releaseLock()));
}
const connectionPromise = this.#driver.acquireConnection(options);
const connection = await waitOrAbort(connectionPromise, options?.signal, "acquireConnection:acquire", () => connectionPromise?.then((connection2) => this.releaseConnection(connection2).catch(printBackgroundFail("driver.releaseConnection"))).catch(printBackgroundFail("driver.acquireConnection")));
if (!this.#connections.has(connection)) {
if (this.#needsLogging()) {
this.#addLogging(connection);
}
this.#connections.add(connection);
}
return connection;
}
async releaseConnection(connection, options) {
await this.#driver.releaseConnection(connection, options);
this.#connectionMutex?.releaseLock();
}
async beginTransaction(connection, settings) {
return await this.#driver.beginTransaction(connection, settings);
}
async commitTransaction(connection) {
return await this.#driver.commitTransaction(connection);
}
async rollbackTransaction(connection) {
return await this.#driver.rollbackTransaction(connection);
}
async savepoint(connection, savepointName, compileQuery) {
if (this.#driver.savepoint) {
return await this.#driver.savepoint(connection, savepointName, compileQuery);
}
throw new Error("The `savepoint` method is not supported by this driver");
}
async rollbackToSavepoint(connection, savepointName, compileQuery) {
if (this.#driver.rollbackToSavepoint) {
return await this.#driver.rollbackToSavepoint(connection, savepointName, compileQuery);
}
throw new Error("The `rollbackToSavepoint` method is not supported by this driver");
}
async releaseSavepoint(connection, savepointName, compileQuery) {
if (this.#driver.releaseSavepoint) {
return await this.#driver.releaseSavepoint(connection, savepointName, compileQuery);
}
throw new Error("The `releaseSavepoint` method is not supported by this driver");
}
async destroy(options) {
if (!this.#initPromise) {
return;
}
await waitOrAbort(this.#initPromise, options?.signal, "destroy:initPromise");
this.#destroyPromise ??= this.#driver.destroy(options).catch((reason) => {
this.#destroyPromise = undefined;
throw reason;
});
await waitOrAbort(this.#destroyPromise, options?.signal, "destroy");
}
#needsLogging() {
return this.#log.isLevelEnabled("query") || this.#log.isLevelEnabled("error");
}
#addLogging(connection) {
const executeQuery = connection.executeQuery;
const streamQuery = connection.streamQuery;
const dis = this;
connection.executeQuery = async (compiledQuery, options) => {
let caughtError;
const startTime = performanceNow();
try {
return await executeQuery.call(connection, compiledQuery, options);
} catch (error) {
caughtError = error;
await dis.#logError(error, compiledQuery, startTime);
throw error;
} finally {
if (!caughtError) {
await dis.#logQuery(compiledQuery, startTime);
}
}
};
connection.streamQuery = async function* (compiledQuery, chunkSize, options) {
let caughtError;
const startTime = performanceNow();
try {
for await (const result of streamQuery.call(connection, compiledQuery, chunkSize, options)) {
yield result;
}
} catch (error) {
caughtError = error;
await dis.#logError(error, compiledQuery, startTime);
throw error;
} finally {
if (!caughtError) {
await dis.#logQuery(compiledQuery, startTime, true);
}
}
};
}
async#logError(error, compiledQuery, startTime) {
await this.#log.error(() => ({
level: "error",
error,
query: compiledQuery,
queryDurationMillis: this.#calculateDurationMillis(startTime)
}));
}
async#logQuery(compiledQuery, startTime, isStream = false) {
await this.#log.query(() => ({
level: "query",
isStream,
query: compiledQuery,
queryDurationMillis: this.#calculateDurationMillis(startTime)
}));
}
#calculateDurationMillis(startTime) {
return performanceNow() - startTime;
}
}
// server/node_modules/kysely/dist/driver/single-connection-provider.js
var ignoreError = () => {};
class SingleConnectionProvider {
#connection;
#runningPromise;
constructor(connection) {
this.#connection = connection;
}
async provideConnection(consumer) {
while (this.#runningPromise) {
await this.#runningPromise.catch(ignoreError);
}
this.#runningPromise = this.#run(consumer).finally(() => {
this.#runningPromise = undefined;
});
return this.#runningPromise;
}
async#run(runner) {
return await runner(this.#connection);
}
}
// server/node_modules/kysely/dist/driver/driver.js
var TRANSACTION_ACCESS_MODES = ["read only", "read write"];
var TRANSACTION_ISOLATION_LEVELS = [
"read uncommitted",
"read committed",
"repeatable read",
"serializable",
"snapshot"
];
function validateTransactionSettings(settings) {
if (settings.accessMode && !TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
throw new Error(`invalid transaction access mode ${settings.accessMode}`);
}
if (settings.isolationLevel && !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
}
}
// server/node_modules/kysely/dist/util/log.js
var logLevels = ["query", "error"];
var LOG_LEVELS = freeze(logLevels);
class Log {
#levels;
#logger;
constructor(config) {
if (isFunction(config)) {
this.#logger = config;
this.#levels = freeze({
query: true,
error: true
});
} else {
this.#logger = defaultLogger;
this.#levels = freeze({
query: config.includes("query"),
error: config.includes("error")
});
}
}
isLevelEnabled(level) {
return this.#levels[level];
}
async query(getEvent) {
if (this.#levels.query) {
await this.#logger(getEvent());
}
}
async error(getEvent) {
if (this.#levels.error) {
await this.#logger(getEvent());
}
}
}
function defaultLogger(event) {
if (event.level === "query") {
const prefix = `kysely:query:${event.isStream ? "stream:" : ""}`;
console.log(`${prefix} ${event.query.sql}`);
console.log(`${prefix} duration: ${event.queryDurationMillis.toFixed(1)}ms`);
} else if (event.level === "error") {
if (event.error instanceof Error) {
console.error(`kysely:error: ${event.error.stack ?? event.error.message}`);
} else {
console.error(`kysely:error: ${JSON.stringify({
error: event.error,
query: event.query.sql,
queryDurationMillis: event.queryDurationMillis
})}`);
}
}
}
// server/node_modules/kysely/dist/util/compilable.js
function isCompilable(value) {
return isObject(value) && isFunction(value.compile);
}
// server/node_modules/kysely/dist/kysely.js
Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
class Kysely extends QueryCreator {
#props;
constructor(args) {
let superProps;
let props;
if (isKyselyProps(args)) {
superProps = { executor: args.executor };
props = { ...args };
} else {
const dialect = args.dialect;
const driver = dialect.createDriver();
const compiler = dialect.createQueryCompiler();
const adapter = dialect.createAdapter();
const log = new Log(args.log ?? []);
const runtimeDriver = new RuntimeDriver(driver, adapter, log);
const connectionProvider = new DefaultConnectionProvider(runtimeDriver);
const executor = new DefaultQueryExecutor(compiler, adapter, connectionProvider, args.plugins ?? []);
superProps = { executor };
props = {
config: args,
executor,
dialect,
driver: runtimeDriver
};
}
super(superProps);
this.#props = freeze(props);
}
get schema() {
return new SchemaModule(this.#props.executor);
}
get dynamic() {
return new DynamicModule;
}
get introspection() {
return this.#props.dialect.createIntrospector(this.withoutPlugins());
}
case(value) {
return new CaseBuilder({
node: CaseNode.create(isUndefined(value) ? undefined : parseExpression(value))
});
}
get fn() {
return createFunctionModule();
}
transaction() {
return new TransactionBuilder({ ...this.#props });
}
startTransaction() {
return new ControlledTransactionBuilder({ ...this.#props });
}
connection() {
return new ConnectionBuilder({ ...this.#props });
}
withPlugin(plugin) {
return new Kysely({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
withoutPlugins() {
return new Kysely({
...this.#props,
executor: this.#props.executor.withoutPlugins()
});
}
withSchema(schema) {
return new Kysely({
...this.#props,
executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
});
}
$extendTables() {
return new Kysely({ ...this.#props });
}
$omitTables() {
return new Kysely({ ...this.#props });
}
$pickTables() {
return new Kysely({ ...this.#props });
}
withTables() {
return this.$extendTables();
}
async destroy() {
await this.#props.driver.destroy();
}
get isTransaction() {
return false;
}
getExecutor() {
return this.#props.executor;
}
async executeQuery(query, options) {
const compiledQuery = isCompilable(query) ? query.compile() : query;
return await this.#props.executor.executeQuery(compiledQuery, options);
}
async[Symbol.asyncDispose]() {
await this.destroy();
}
}
class Transaction extends Kysely {
#props;
constructor(props) {
super(props);
this.#props = props;
}
get isTransaction() {
return true;
}
transaction() {
throw new Error("calling the transaction method for a Transaction is not supported");
}
startTransaction() {
throw new Error("calling the controlled transaction method for a Transaction is not supported");
}
connection() {
throw new Error("calling the connection method for a Transaction is not supported");
}
destroy() {
throw new Error("calling the destroy method for a Transaction is not supported");
}
withPlugin(plugin) {
return new Transaction({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
withoutPlugins() {
return new Transaction({
...this.#props,
executor: this.#props.executor.withoutPlugins()
});
}
withSchema(schema) {
return new Transaction({
...this.#props,
executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
});
}
withTables() {
return new Transaction({ ...this.#props });
}
$extendTables() {
return new Transaction({ ...this.#props });
}
$omitTables() {
return new Transaction({ ...this.#props });
}
$pickTables() {
return new Transaction({ ...this.#props });
}
}
function isKyselyProps(obj) {
return isObject(obj) && isObject(obj.config) && isObject(obj.driver) && isObject(obj.executor) && isObject(obj.dialect);
}
class ConnectionBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
async execute(callback, options) {
return this.#props.executor.provideConnection(async (connection) => {
const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
const db = new Kysely({ ...this.#props, executor });
return await callback(db);
}, freeze({ signal: options?.signal }));
}
}
class TransactionBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
setAccessMode(accessMode) {
return new TransactionBuilder({
...this.#props,
accessMode
});
}
setIsolationLevel(isolationLevel) {
return new TransactionBuilder({
...this.#props,
isolationLevel
});
}
async execute(callback) {
const { isolationLevel, accessMode, ...kyselyProps } = this.#props;
const settings = { isolationLevel, accessMode };
validateTransactionSettings(settings);
return this.#props.executor.provideConnection(async (connection) => {
const state = { isCommitted: false, isRolledBack: false };
const executor = new NotCommittedOrRolledBackAssertingExecutor(this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection)), state);
const transaction = new Transaction({ ...kyselyProps, executor });
let transactionBegun = false;
try {
await this.#props.driver.beginTransaction(connection, settings);
transactionBegun = true;
const result = await callback(transaction);
await this.#props.driver.commitTransaction(connection);
state.isCommitted = true;
return result;
} catch (error) {
if (transactionBegun) {
await this.#props.driver.rollbackTransaction(connection);
state.isRolledBack = true;
}
throw error;
}
});
}
}
class ControlledTransactionBuilder {
#props;
constructor(props) {
this.#props = freeze(props);
}
setAccessMode(accessMode) {
return new ControlledTransactionBuilder({
...this.#props,
accessMode
});
}
setIsolationLevel(isolationLevel) {
return new ControlledTransactionBuilder({
...this.#props,
isolationLevel
});
}
async execute() {
const { isolationLevel, accessMode, ...props } = this.#props;
const settings = { isolationLevel, accessMode };
validateTransactionSettings(settings);
const connection = await provideControlledConnection(this.#props.executor);
await this.#props.driver.beginTransaction(connection.connection, settings);
return new ControlledTransaction({
...props,
connection,
executor: this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection.connection))
});
}
}
class ControlledTransaction extends Transaction {
#props;
#compileQuery;
#state;
constructor(props) {
const state = { isCommitted: false, isRolledBack: false };
props = {
...props,
executor: new NotCommittedOrRolledBackAssertingExecutor(props.executor, state)
};
const { connection, ...transactionProps } = props;
super(transactionProps);
this.#props = freeze(props);
this.#state = state;
const queryId = createQueryId();
this.#compileQuery = (node) => props.executor.compileQuery(node, queryId);
}
get isCommitted() {
return this.#state.isCommitted;
}
get isRolledBack() {
return this.#state.isRolledBack;
}
commit() {
assertNotCommittedOrRolledBack(this.#state);
return new Command(async () => {
await this.#props.driver.commitTransaction(this.#props.connection.connection);
this.#state.isCommitted = true;
this.#props.connection.release();
});
}
rollback() {
assertNotCommittedOrRolledBack(this.#state);
return new Command(async () => {
await this.#props.driver.rollbackTransaction(this.#props.connection.connection);
this.#state.isRolledBack = true;
this.#props.connection.release();
});
}
savepoint(savepointName) {
assertNotCommittedOrRolledBack(this.#state);
return new Command(async () => {
await this.#props.driver.savepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
return new ControlledTransaction({ ...this.#props });
});
}
rollbackToSavepoint(savepointName) {
assertNotCommittedOrRolledBack(this.#state);
return new Command(async () => {
await this.#props.driver.rollbackToSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
return new ControlledTransaction({ ...this.#props });
});
}
releaseSavepoint(savepointName) {
assertNotCommittedOrRolledBack(this.#state);
return new Command(async () => {
await this.#props.driver.releaseSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
return new ControlledTransaction({ ...this.#props });
});
}
withPlugin(plugin) {
return new ControlledTransaction({
...this.#props,
executor: this.#props.executor.withPlugin(plugin)
});
}
withoutPlugins() {
return new ControlledTransaction({
...this.#props,
executor: this.#props.executor.withoutPlugins()
});
}
withSchema(schema) {
return new ControlledTransaction({
...this.#props,
executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema))
});
}
withTables() {
return new ControlledTransaction({ ...this.#props });
}
$extendTables() {
return new ControlledTransaction({ ...this.#props });
}
$omitTables() {
return new ControlledTransaction({ ...this.#props });
}
$pickTables() {
return new ControlledTransaction({ ...this.#props });
}
}
class Command {
#cb;
constructor(cb) {
this.#cb = cb;
}
async execute() {
return await this.#cb();
}
}
function assertNotCommittedOrRolledBack(state) {
if (state.isCommitted) {
throw new Error("Transaction is already committed");
}
if (state.isRolledBack) {
throw new Error("Transaction is already rolled back");
}
}
class NotCommittedOrRolledBackAssertingExecutor {
#executor;
#state;
constructor(executor, state) {
this.#executor = executor instanceof NotCommittedOrRolledBackAssertingExecutor ? executor.#executor : executor;
this.#state = state;
}
get adapter() {
return this.#executor.adapter;
}
get plugins() {
return this.#executor.plugins;
}
transformQuery(node, queryId) {
return this.#executor.transformQuery(node, queryId);
}
compileQuery(node, queryId) {
return this.#executor.compileQuery(node, queryId);
}
provideConnection(consumer, options) {
return this.#executor.provideConnection(consumer, options);
}
executeQuery(compiledQuery, options) {
assertNotCommittedOrRolledBack(this.#state);
return this.#executor.executeQuery(compiledQuery, options);
}
stream(compiledQuery, chunkSize, options) {
assertNotCommittedOrRolledBack(this.#state);
return this.#executor.stream(compiledQuery, chunkSize, options);
}
withConnectionProvider(connectionProvider) {
return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withConnectionProvider(connectionProvider), this.#state);
}
withPlugin(plugin) {
return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugin(plugin), this.#state);
}
withPlugins(plugins) {
return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPlugins(plugins), this.#state);
}
withPluginAtFront(plugin) {
return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withPluginAtFront(plugin), this.#state);
}
withoutPlugins() {
return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withoutPlugins(), this.#state);
}
}
// server/node_modules/kysely/dist/raw-builder/raw-builder.js
class RawBuilderImpl {
#props;
constructor(props) {
this.#props = freeze(props);
}
get expressionType() {
return;
}
get isRawBuilder() {
return true;
}
as(alias) {
return new AliasedRawBuilderImpl(this, alias);
}
$castTo() {
return new RawBuilderImpl({ ...this.#props });
}
$notNull() {
return new RawBuilderImpl(this.#props);
}
withPlugin(plugin) {
return new RawBuilderImpl({
...this.#props,
plugins: this.#props.plugins !== undefined ? freeze([...this.#props.plugins, plugin]) : freeze([plugin])
});
}
toOperationNode() {
return this.#toOperationNode(this.#getExecutor());
}
compile(executorProvider) {
return this.#compile(this.#getExecutor(executorProvider));
}
async execute(executorProvider, options) {
const executor = this.#getExecutor(executorProvider);
return executor.executeQuery(this.#compile(executor), options);
}
#getExecutor(executorProvider) {
const executor = executorProvider !== undefined ? executorProvider.getExecutor() : NOOP_QUERY_EXECUTOR;
return this.#props.plugins !== undefined ? executor.withPlugins(this.#props.plugins) : executor;
}
#toOperationNode(executor) {
return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
}
#compile(executor) {
return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
}
}
function createRawBuilder(props) {
return new RawBuilderImpl(props);
}
class AliasedRawBuilderImpl {
#rawBuilder;
#alias;
constructor(rawBuilder, alias) {
this.#rawBuilder = rawBuilder;
this.#alias = alias;
}
get expression() {
return this.#rawBuilder;
}
get alias() {
return this.#alias;
}
get rawBuilder() {
return this.#rawBuilder;
}
toOperationNode() {
return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias) ? this.#alias.toOperationNode() : IdentifierNode.create(this.#alias));
}
}
// server/node_modules/kysely/dist/raw-builder/sql.js
var sql = Object.assign((sqlFragments, ...parameters) => {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.create(sqlFragments, parameters?.map(parseParameter) ?? [])
});
}, {
ref(columnReference) {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithChild(parseStringReference(columnReference))
});
},
val(value) {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithChild(parseValueExpression(value))
});
},
table(tableReference) {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithChild(parseTable(tableReference))
});
},
id(...ids) {
const fragments = new Array(ids.length + 1).fill(".");
fragments[0] = "";
fragments[fragments.length - 1] = "";
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create))
});
},
lit(value) {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithChild(ValueNode.createImmediate(value))
});
},
raw(sql2) {
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithSql(sql2)
});
},
join(array, separator = sql`, `) {
const nodes = new Array(Math.max(2 * array.length - 1, 0));
const sep = separator.toOperationNode();
for (let i = 0;i < array.length; ++i) {
nodes[2 * i] = parseParameter(array[i]);
if (i !== array.length - 1) {
nodes[2 * i + 1] = sep;
}
}
return createRawBuilder({
queryId: createQueryId(),
rawNode: RawNode.createWithChildren(nodes)
});
}
});
function parseParameter(param) {
if (isOperationNodeSource(param)) {
return param.toOperationNode();
}
return parseValueExpression(param);
}
// server/node_modules/kysely/dist/operation-node/operation-node-visitor.js
class OperationNodeVisitor {
nodeStack = [];
get parentNode() {
return this.nodeStack[this.nodeStack.length - 2];
}
#visitors = freeze({
AliasNode: this.visitAlias.bind(this),
ColumnNode: this.visitColumn.bind(this),
IdentifierNode: this.visitIdentifier.bind(this),
SchemableIdentifierNode: this.visitSchemableIdentifier.bind(this),
RawNode: this.visitRaw.bind(this),
ReferenceNode: this.visitReference.bind(this),
SelectQueryNode: this.visitSelectQuery.bind(this),
SelectionNode: this.visitSelection.bind(this),
TableNode: this.visitTable.bind(this),
FromNode: this.visitFrom.bind(this),
SelectAllNode: this.visitSelectAll.bind(this),
AndNode: this.visitAnd.bind(this),
OrNode: this.visitOr.bind(this),
ValueNode: this.visitValue.bind(this),
ValueListNode: this.visitValueList.bind(this),
PrimitiveValueListNode: this.visitPrimitiveValueList.bind(this),
ParensNode: this.visitParens.bind(this),
JoinNode: this.visitJoin.bind(this),
OperatorNode: this.visitOperator.bind(this),
WhereNode: this.visitWhere.bind(this),
InsertQueryNode: this.visitInsertQuery.bind(this),
DeleteQueryNode: this.visitDeleteQuery.bind(this),
ReturningNode: this.visitReturning.bind(this),
CreateTableNode: this.visitCreateTable.bind(this),
AddColumnNode: this.visitAddColumn.bind(this),
ColumnDefinitionNode: this.visitColumnDefinition.bind(this),
DropTableNode: this.visitDropTable.bind(this),
DataTypeNode: this.visitDataType.bind(this),
OrderByNode: this.visitOrderBy.bind(this),
OrderByItemNode: this.visitOrderByItem.bind(this),
GroupByNode: this.visitGroupBy.bind(this),
GroupByItemNode: this.visitGroupByItem.bind(this),
UpdateQueryNode: this.visitUpdateQuery.bind(this),
ColumnUpdateNode: this.visitColumnUpdate.bind(this),
LimitNode: this.visitLimit.bind(this),
OffsetNode: this.visitOffset.bind(this),
OnConflictNode: this.visitOnConflict.bind(this),
OnDuplicateKeyNode: this.visitOnDuplicateKey.bind(this),
CreateIndexNode: this.visitCreateIndex.bind(this),
DropIndexNode: this.visitDropIndex.bind(this),
ListNode: this.visitList.bind(this),
PrimaryKeyConstraintNode: this.visitPrimaryKeyConstraint.bind(this),
UniqueConstraintNode: this.visitUniqueConstraint.bind(this),
ReferencesNode: this.visitReferences.bind(this),
CheckConstraintNode: this.visitCheckConstraint.bind(this),
WithNode: this.visitWith.bind(this),
CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
HavingNode: this.visitHaving.bind(this),
CreateSchemaNode: this.visitCreateSchema.bind(this),
DropSchemaNode: this.visitDropSchema.bind(this),
AlterTableNode: this.visitAlterTable.bind(this),
DropColumnNode: this.visitDropColumn.bind(this),
RenameColumnNode: this.visitRenameColumn.bind(this),
AlterColumnNode: this.visitAlterColumn.bind(this),
ModifyColumnNode: this.visitModifyColumn.bind(this),
AddConstraintNode: this.visitAddConstraint.bind(this),
DropConstraintNode: this.visitDropConstraint.bind(this),
RenameConstraintNode: this.visitRenameConstraint.bind(this),
ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
CreateViewNode: this.visitCreateView.bind(this),
RefreshMaterializedViewNode: this.visitRefreshMaterializedView.bind(this),
DropViewNode: this.visitDropView.bind(this),
GeneratedNode: this.visitGenerated.bind(this),
DefaultValueNode: this.visitDefaultValue.bind(this),
OnNode: this.visitOn.bind(this),
ValuesNode: this.visitValues.bind(this),
SelectModifierNode: this.visitSelectModifier.bind(this),
CreateTypeNode: this.visitCreateType.bind(this),
DropTypeNode: this.visitDropType.bind(this),
ExplainNode: this.visitExplain.bind(this),
DefaultInsertValueNode: this.visitDefaultInsertValue.bind(this),
AggregateFunctionNode: this.visitAggregateFunction.bind(this),
OverNode: this.visitOver.bind(this),
PartitionByNode: this.visitPartitionBy.bind(this),
PartitionByItemNode: this.visitPartitionByItem.bind(this),
SetOperationNode: this.visitSetOperation.bind(this),
BinaryOperationNode: this.visitBinaryOperation.bind(this),
UnaryOperationNode: this.visitUnaryOperation.bind(this),
UsingNode: this.visitUsing.bind(this),
FunctionNode: this.visitFunction.bind(this),
CaseNode: this.visitCase.bind(this),
WhenNode: this.visitWhen.bind(this),
JSONReferenceNode: this.visitJSONReference.bind(this),
JSONPathNode: this.visitJSONPath.bind(this),
JSONPathLegNode: this.visitJSONPathLeg.bind(this),
JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
TupleNode: this.visitTuple.bind(this),
MergeQueryNode: this.visitMergeQuery.bind(this),
MatchedNode: this.visitMatched.bind(this),
AddIndexNode: this.visitAddIndex.bind(this),
CastNode: this.visitCast.bind(this),
FetchNode: this.visitFetch.bind(this),
TopNode: this.visitTop.bind(this),
OutputNode: this.visitOutput.bind(this),
OrActionNode: this.visitOrAction.bind(this),
CollateNode: this.visitCollate.bind(this),
AlterTypeNode: this.visitAlterType.bind(this),
AddValueNode: this.visitAddValue.bind(this),
RenameValueNode: this.visitRenameValue.bind(this)
});
visitNode = (node) => {
this.nodeStack.push(node);
this.#visitors[node.kind](node);
this.nodeStack.pop();
};
}
// server/node_modules/kysely/dist/query-compiler/default-query-compiler.js
var LIT_WRAP_REGEX = /'/g;
var JSON_PATH_MEMBER_WRAP_REGEX = /['"]/g;
class DefaultQueryCompiler extends OperationNodeVisitor {
#sql = "";
#parameters = [];
get numParameters() {
return this.#parameters.length;
}
compileQuery(node, queryId) {
this.#sql = "";
this.#parameters = [];
this.nodeStack.splice(0, this.nodeStack.length);
this.visitNode(node);
return freeze({
query: node,
queryId,
sql: this.getSql(),
parameters: [...this.#parameters]
});
}
getSql() {
return this.#sql;
}
visitSelectQuery(node) {
const wrapInParens = this.parentNode !== undefined && !ParensNode.is(this.parentNode) && !InsertQueryNode.is(this.parentNode) && !CreateTableNode.is(this.parentNode) && !CreateViewNode.is(this.parentNode) && !SetOperationNode.is(this.parentNode);
if (this.parentNode === undefined && node.explain) {
this.visitNode(node.explain);
this.append(" ");
}
if (wrapInParens) {
this.append("(");
}
if (node.with) {
this.visitNode(node.with);
this.append(" ");
}
this.append("select");
if (node.distinctOn) {
this.append(" ");
this.compileDistinctOn(node.distinctOn);
}
if (node.frontModifiers?.length) {
this.append(" ");
this.compileList(node.frontModifiers, " ");
}
if (node.top) {
this.append(" ");
this.visitNode(node.top);
}
if (node.selections) {
this.append(" ");
this.compileList(node.selections);
}
if (node.from) {
this.append(" ");
this.visitNode(node.from);
}
if (node.joins) {
this.append(" ");
this.compileList(node.joins, " ");
}
if (node.where) {
this.append(" ");
this.visitNode(node.where);
}
if (node.groupBy) {
this.append(" ");
this.visitNode(node.groupBy);
}
if (node.having) {
this.append(" ");
this.visitNode(node.having);
}
if (node.setOperations) {
this.append(" ");
this.compileList(node.setOperations, " ");
}
if (node.orderBy) {
this.append(" ");
this.visitNode(node.orderBy);
}
if (node.limit) {
this.append(" ");
this.visitNode(node.limit);
}
if (node.offset) {
this.append(" ");
this.visitNode(node.offset);
}
if (node.fetch) {
this.append(" ");
this.visitNode(node.fetch);
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(this.sortSelectModifiers(node.endModifiers), " ");
}
if (wrapInParens) {
this.append(")");
}
}
visitFrom(node) {
this.append("from ");
this.compileList(node.froms);
}
visitSelection(node) {
this.visitNode(node.selection);
}
visitColumn(node) {
this.visitNode(node.column);
}
compileDistinctOn(expressions) {
this.append("distinct on (");
this.compileList(expressions);
this.append(")");
}
compileList(nodes, separator = ", ") {
const lastIndex = nodes.length - 1;
for (let i = 0;i <= lastIndex; i++) {
this.visitNode(nodes[i]);
if (i < lastIndex) {
this.append(separator);
}
}
}
visitWhere(node) {
this.append("where ");
this.visitNode(node.where);
}
visitHaving(node) {
this.append("having ");
this.visitNode(node.having);
}
visitInsertQuery(node) {
const wrapInParens = this.parentNode !== undefined && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode) && !WhenNode.is(this.parentNode);
if (this.parentNode === undefined && node.explain) {
this.visitNode(node.explain);
this.append(" ");
}
if (wrapInParens) {
this.append("(");
}
if (node.with) {
this.visitNode(node.with);
this.append(" ");
}
this.append(node.replace ? "replace" : "insert");
if (node.orAction) {
this.append(" ");
this.visitNode(node.orAction);
}
if (node.top) {
this.append(" ");
this.visitNode(node.top);
}
if (node.into) {
this.append(" into ");
this.visitNode(node.into);
}
if (node.columns) {
this.append(" (");
this.compileList(node.columns);
this.append(")");
}
if (node.output) {
this.append(" ");
this.visitNode(node.output);
}
if (node.values) {
this.append(" ");
this.visitNode(node.values);
}
if (node.defaultValues) {
this.append(" ");
this.append("default values");
}
if (node.onConflict) {
this.append(" ");
this.visitNode(node.onConflict);
}
if (node.onDuplicateKey) {
this.append(" ");
this.visitNode(node.onDuplicateKey);
}
if (node.returning) {
this.append(" ");
this.visitNode(node.returning);
}
if (wrapInParens) {
this.append(")");
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
}
visitValues(node) {
this.append("values ");
this.compileList(node.values);
}
visitDeleteQuery(node) {
const wrapInParens = this.parentNode !== undefined && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode);
if (this.parentNode === undefined && node.explain) {
this.visitNode(node.explain);
this.append(" ");
}
if (wrapInParens) {
this.append("(");
}
if (node.with) {
this.visitNode(node.with);
this.append(" ");
}
this.append("delete ");
if (node.top) {
this.visitNode(node.top);
this.append(" ");
}
this.visitNode(node.from);
if (node.output) {
this.append(" ");
this.visitNode(node.output);
}
if (node.using) {
this.append(" ");
this.visitNode(node.using);
}
if (node.joins) {
this.append(" ");
this.compileList(node.joins, " ");
}
if (node.where) {
this.append(" ");
this.visitNode(node.where);
}
if (node.returning) {
this.append(" ");
this.visitNode(node.returning);
}
if (node.orderBy) {
this.append(" ");
this.visitNode(node.orderBy);
}
if (node.limit) {
this.append(" ");
this.visitNode(node.limit);
}
if (wrapInParens) {
this.append(")");
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
}
visitReturning(node) {
this.append("returning ");
this.compileList(node.selections);
}
visitAlias(node) {
this.visitNode(node.node);
this.append(" as ");
this.visitNode(node.alias);
}
visitReference(node) {
if (node.table) {
this.visitNode(node.table);
this.append(".");
}
this.visitNode(node.column);
}
visitSelectAll(_) {
this.append("*");
}
visitIdentifier(node) {
this.append(this.getLeftIdentifierWrapper());
this.compileUnwrappedIdentifier(node);
this.append(this.getRightIdentifierWrapper());
}
compileUnwrappedIdentifier(node) {
if (!isString(node.name)) {
throw new Error("a non-string identifier was passed to compileUnwrappedIdentifier.");
}
this.append(this.sanitizeIdentifier(node.name));
}
visitAnd(node) {
this.visitNode(node.left);
this.append(" and ");
this.visitNode(node.right);
}
visitOr(node) {
this.visitNode(node.left);
this.append(" or ");
this.visitNode(node.right);
}
visitValue(node) {
if (node.immediate) {
this.appendImmediateValue(node.value);
} else {
this.appendValue(node.value);
}
}
visitValueList(node) {
this.append("(");
this.compileList(node.values);
this.append(")");
}
visitTuple(node) {
this.append("(");
this.compileList(node.values);
this.append(")");
}
visitPrimitiveValueList(node) {
this.append("(");
const { values } = node;
for (let i = 0;i < values.length; ++i) {
this.appendValue(values[i]);
if (i !== values.length - 1) {
this.append(", ");
}
}
this.append(")");
}
visitParens(node) {
this.append("(");
this.visitNode(node.node);
this.append(")");
}
visitJoin(node) {
this.append(JOIN_TYPE_SQL[node.joinType]);
this.append(" ");
this.visitNode(node.table);
if (node.on) {
this.append(" ");
this.visitNode(node.on);
}
}
visitOn(node) {
this.append("on ");
this.visitNode(node.on);
}
visitRaw(node) {
const { sqlFragments, parameters: params } = node;
for (let i = 0;i < sqlFragments.length; ++i) {
this.append(sqlFragments[i]);
if (params.length > i) {
this.visitNode(params[i]);
}
}
}
visitOperator(node) {
this.append(node.operator);
}
visitTable(node) {
this.visitNode(node.table);
}
visitSchemableIdentifier(node) {
if (node.schema) {
this.visitNode(node.schema);
this.append(".");
}
this.visitNode(node.identifier);
}
visitCreateTable(node) {
this.append("create ");
if (node.frontModifiers?.length) {
this.compileList(node.frontModifiers, " ");
this.append(" ");
}
if (node.temporary) {
this.append("temporary ");
}
this.append("table ");
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.table);
if (!node.selectQuery) {
this.append(" (");
this.compileList([
...node.columns,
...node.constraints ?? [],
...node.indexes ?? []
]);
this.append(")");
}
if (node.onCommit) {
this.append(" on commit ");
this.append(node.onCommit);
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
if (node.selectQuery) {
this.append(" as ");
this.visitNode(node.selectQuery);
}
}
visitColumnDefinition(node) {
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.column);
this.append(" ");
this.visitNode(node.dataType);
if (node.unsigned) {
this.append(" unsigned");
}
if (node.frontModifiers && node.frontModifiers.length > 0) {
this.append(" ");
this.compileList(node.frontModifiers, " ");
}
if (node.generated) {
this.append(" ");
this.visitNode(node.generated);
}
if (node.identity) {
this.append(" identity");
}
if (node.defaultTo) {
this.append(" ");
this.visitNode(node.defaultTo);
}
if (node.notNull) {
this.append(" not null");
}
if (node.unique) {
this.append(" unique");
}
if (node.nullsNotDistinct) {
this.append(" nulls not distinct");
}
if (node.primaryKey) {
this.append(" primary key");
}
if (node.autoIncrement) {
this.append(" ");
this.append(this.getAutoIncrement());
}
if (node.references) {
this.append(" ");
this.visitNode(node.references);
}
if (node.check) {
this.append(" ");
this.visitNode(node.check);
}
if (node.endModifiers && node.endModifiers.length > 0) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
}
getAutoIncrement() {
return "auto_increment";
}
visitReferences(node) {
this.append("references ");
this.visitNode(node.table);
this.append(" (");
this.compileList(node.columns);
this.append(")");
if (node.onDelete) {
this.append(" on delete ");
this.append(node.onDelete);
}
if (node.onUpdate) {
this.append(" on update ");
this.append(node.onUpdate);
}
}
visitDropTable(node) {
this.append("drop ");
if (node.temporary) {
this.append("temporary ");
}
this.append("table ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.table);
if (node.cascade) {
this.append(" cascade");
}
}
visitDataType(node) {
this.append(node.dataType);
}
visitOrderBy(node) {
this.append("order by ");
this.compileList(node.items);
}
visitOrderByItem(node) {
this.visitNode(node.orderBy);
if (node.collation) {
this.append(" ");
this.visitNode(node.collation);
}
if (node.direction) {
this.append(" ");
this.visitNode(node.direction);
}
if (node.nulls) {
this.append(" nulls ");
this.append(node.nulls);
}
}
visitGroupBy(node) {
this.append("group by ");
this.compileList(node.items);
}
visitGroupByItem(node) {
this.visitNode(node.groupBy);
}
visitUpdateQuery(node) {
const wrapInParens = this.parentNode !== undefined && !ParensNode.is(this.parentNode) && !RawNode.is(this.parentNode) && !WhenNode.is(this.parentNode);
if (this.parentNode === undefined && node.explain) {
this.visitNode(node.explain);
this.append(" ");
}
if (wrapInParens) {
this.append("(");
}
if (node.with) {
this.visitNode(node.with);
this.append(" ");
}
this.append("update ");
if (node.top) {
this.visitNode(node.top);
this.append(" ");
}
if (node.table) {
this.visitNode(node.table);
this.append(" ");
}
this.append("set ");
if (node.updates) {
this.compileList(node.updates);
}
if (node.output) {
this.append(" ");
this.visitNode(node.output);
}
if (node.from) {
this.append(" ");
this.visitNode(node.from);
}
if (node.joins) {
if (!node.from) {
throw new Error("Joins in an update query are only supported as a part of a PostgreSQL 'update set from join' query. If you want to create a MySQL 'update join set' query, see https://kysely.dev/docs/examples/update/my-sql-joins");
}
this.append(" ");
this.compileList(node.joins, " ");
}
if (node.where) {
this.append(" ");
this.visitNode(node.where);
}
if (node.returning) {
this.append(" ");
this.visitNode(node.returning);
}
if (node.orderBy) {
this.append(" ");
this.visitNode(node.orderBy);
}
if (node.limit) {
this.append(" ");
this.visitNode(node.limit);
}
if (wrapInParens) {
this.append(")");
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
}
visitColumnUpdate(node) {
this.visitNode(node.column);
this.append(" = ");
this.visitNode(node.value);
}
visitLimit(node) {
this.append("limit ");
this.visitNode(node.limit);
}
visitOffset(node) {
this.append("offset ");
this.visitNode(node.offset);
}
visitOnConflict(node) {
this.append("on conflict");
if (node.columns) {
this.append(" (");
this.compileList(node.columns);
this.append(")");
} else if (node.constraint) {
this.append(" on constraint ");
this.visitNode(node.constraint);
} else if (node.indexExpression) {
this.append(" (");
this.visitNode(node.indexExpression);
this.append(")");
}
if (node.indexWhere) {
this.append(" ");
this.visitNode(node.indexWhere);
}
if (node.doNothing === true) {
this.append(" do nothing");
} else if (node.updates) {
this.append(" do update set ");
this.compileList(node.updates);
if (node.updateWhere) {
this.append(" ");
this.visitNode(node.updateWhere);
}
}
}
visitOnDuplicateKey(node) {
this.append("on duplicate key update ");
this.compileList(node.updates);
}
visitCreateIndex(node) {
this.append("create ");
if (node.unique) {
this.append("unique ");
}
this.append("index ");
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.name);
if (node.table) {
this.append(" on ");
this.visitNode(node.table);
}
if (node.using) {
this.append(" using ");
this.visitNode(node.using);
}
if (node.columns) {
this.append(" (");
this.compileList(node.columns);
this.append(")");
}
if (node.nullsNotDistinct) {
this.append(" nulls not distinct");
}
if (node.where) {
this.append(" ");
this.visitNode(node.where);
}
}
visitDropIndex(node) {
this.append("drop index ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.name);
if (node.table) {
this.append(" on ");
this.visitNode(node.table);
}
if (node.cascade) {
this.append(" cascade");
}
}
visitCreateSchema(node) {
this.append("create schema ");
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.schema);
}
visitDropSchema(node) {
this.append("drop schema ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.schema);
if (node.cascade) {
this.append(" cascade");
}
}
visitPrimaryKeyConstraint(node) {
if (node.name) {
this.append("constraint ");
this.visitNode(node.name);
this.append(" ");
}
this.append("primary key (");
this.compileList(node.columns);
this.append(")");
this.buildDeferrable(node);
}
buildDeferrable(node) {
if (node.deferrable !== undefined) {
if (node.deferrable) {
this.append(" deferrable");
} else {
this.append(" not deferrable");
}
}
if (node.initiallyDeferred !== undefined) {
if (node.initiallyDeferred) {
this.append(" initially deferred");
} else {
this.append(" initially immediate");
}
}
}
visitUniqueConstraint(node) {
if (node.name) {
this.append("constraint ");
this.visitNode(node.name);
this.append(" ");
}
this.append("unique");
if (node.nullsNotDistinct) {
this.append(" nulls not distinct");
}
this.append(" (");
this.compileList(node.columns);
this.append(")");
this.buildDeferrable(node);
}
visitCheckConstraint(node) {
if (node.name) {
this.append("constraint ");
this.visitNode(node.name);
this.append(" ");
}
this.append("check (");
this.visitNode(node.expression);
this.append(")");
}
visitForeignKeyConstraint(node) {
if (node.name) {
this.append("constraint ");
this.visitNode(node.name);
this.append(" ");
}
this.append("foreign key (");
this.compileList(node.columns);
this.append(") ");
this.visitNode(node.references);
if (node.onDelete) {
this.append(" on delete ");
this.append(node.onDelete);
}
if (node.onUpdate) {
this.append(" on update ");
this.append(node.onUpdate);
}
this.buildDeferrable(node);
}
visitList(node) {
this.compileList(node.items);
}
visitWith(node) {
this.append("with ");
if (node.recursive) {
this.append("recursive ");
}
this.compileList(node.expressions);
}
visitCommonTableExpression(node) {
this.visitNode(node.name);
this.append(" as ");
if (isBoolean(node.materialized)) {
if (!node.materialized) {
this.append("not ");
}
this.append("materialized ");
}
this.visitNode(node.expression);
}
visitCommonTableExpressionName(node) {
this.visitNode(node.table);
if (node.columns) {
this.append("(");
this.compileList(node.columns);
this.append(")");
}
}
visitAlterTable(node) {
this.append("alter table ");
this.visitNode(node.table);
this.append(" ");
if (node.renameTo) {
this.append("rename to ");
this.visitNode(node.renameTo);
}
if (node.setSchema) {
this.append("set schema ");
this.visitNode(node.setSchema);
}
if (node.addConstraint) {
this.visitNode(node.addConstraint);
}
if (node.dropConstraint) {
this.visitNode(node.dropConstraint);
}
if (node.renameConstraint) {
this.visitNode(node.renameConstraint);
}
if (node.columnAlterations) {
this.compileColumnAlterations(node.columnAlterations);
}
if (node.addIndex) {
this.visitNode(node.addIndex);
}
if (node.dropIndex) {
this.visitNode(node.dropIndex);
}
}
visitAddColumn(node) {
this.append("add column ");
this.visitNode(node.column);
}
visitRenameColumn(node) {
this.append("rename column ");
this.visitNode(node.column);
this.append(" to ");
this.visitNode(node.renameTo);
}
visitDropColumn(node) {
this.append("drop column ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.column);
}
visitAlterColumn(node) {
this.append("alter column ");
this.visitNode(node.column);
this.append(" ");
if (node.dataType) {
if (this.announcesNewColumnDataType()) {
this.append("type ");
}
this.visitNode(node.dataType);
if (node.dataTypeExpression) {
this.append("using ");
this.visitNode(node.dataTypeExpression);
}
}
if (node.setDefault) {
this.append("set default ");
this.visitNode(node.setDefault);
}
if (node.dropDefault) {
this.append("drop default");
}
if (node.setNotNull) {
this.append("set not null");
}
if (node.dropNotNull) {
this.append("drop not null");
}
}
visitModifyColumn(node) {
this.append("modify column ");
this.visitNode(node.column);
}
visitAddConstraint(node) {
this.append("add ");
this.visitNode(node.constraint);
}
visitDropConstraint(node) {
this.append("drop constraint ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.constraintName);
if (node.modifier === "cascade") {
this.append(" cascade");
} else if (node.modifier === "restrict") {
this.append(" restrict");
}
}
visitRenameConstraint(node) {
this.append("rename constraint ");
this.visitNode(node.oldName);
this.append(" to ");
this.visitNode(node.newName);
}
visitSetOperation(node) {
this.append(node.operator);
this.append(" ");
if (node.all) {
this.append("all ");
}
this.visitNode(node.expression);
}
visitCreateView(node) {
this.append("create ");
if (node.orReplace) {
this.append("or replace ");
}
if (node.materialized) {
this.append("materialized ");
}
if (node.temporary) {
this.append("temporary ");
}
this.append("view ");
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.name);
this.append(" ");
if (node.columns) {
this.append("(");
this.compileList(node.columns);
this.append(") ");
}
if (node.as) {
this.append("as ");
this.visitNode(node.as);
}
}
visitRefreshMaterializedView(node) {
this.append("refresh materialized view ");
if (node.concurrently) {
this.append("concurrently ");
}
this.visitNode(node.name);
if (node.withNoData) {
this.append(" with no data");
} else {
this.append(" with data");
}
}
visitDropView(node) {
this.append("drop ");
if (node.materialized) {
this.append("materialized ");
}
this.append("view ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.name);
if (node.cascade) {
this.append(" cascade");
}
}
visitGenerated(node) {
this.append("generated ");
if (node.always) {
this.append("always ");
}
if (node.byDefault) {
this.append("by default ");
}
this.append("as ");
if (node.identity) {
this.append("identity");
}
if (node.expression) {
this.append("(");
this.visitNode(node.expression);
this.append(")");
}
if (node.stored) {
this.append(" stored");
}
}
visitDefaultValue(node) {
this.append("default ");
this.visitNode(node.defaultValue);
}
visitSelectModifier(node) {
if (node.rawModifier) {
this.visitNode(node.rawModifier);
} else {
this.append(SELECT_MODIFIER_SQL[node.modifier]);
}
if (node.of) {
this.append(" of ");
this.compileList(node.of, ", ");
}
}
visitCreateType(node) {
this.append("create type ");
this.visitNode(node.name);
if (node.enum) {
this.append(" as enum ");
this.visitNode(node.enum);
}
}
visitDropType(node) {
this.append("drop type ");
if (node.ifExists) {
this.append("if exists ");
}
this.visitNode(node.name);
if (node.additionalNames?.length) {
this.append(", ");
this.compileList(node.additionalNames);
}
if (node.cascade) {
this.append(" cascade");
}
}
visitAlterType(node) {
this.append("alter type ");
this.visitNode(node.name);
this.append(" ");
if (node.addValue) {
this.visitNode(node.addValue);
} else if (node.renameTo) {
this.append("rename to ");
this.visitNode(node.renameTo);
} else if (node.renameValue) {
this.visitNode(node.renameValue);
} else if (node.setSchema) {
this.append("set schema ");
this.visitNode(node.setSchema);
}
}
visitAddValue(node) {
this.append("add value ");
if (node.ifNotExists) {
this.append("if not exists ");
}
this.visitNode(node.value);
if (node.neighborValue) {
this.append(node.isBefore ? " before " : " after ");
this.visitNode(node.neighborValue);
}
}
visitRenameValue(node) {
this.append("rename value ");
this.visitNode(node.oldValue);
this.append(" to ");
this.visitNode(node.newValue);
}
visitExplain(node) {
this.append("explain");
if (node.options || node.format) {
this.append(" ");
this.append(this.getLeftExplainOptionsWrapper());
if (node.options) {
this.visitNode(node.options);
if (node.format) {
this.append(this.getExplainOptionsDelimiter());
}
}
if (node.format) {
this.append("format");
this.append(this.getExplainOptionAssignment());
this.append(node.format);
}
this.append(this.getRightExplainOptionsWrapper());
}
}
visitDefaultInsertValue(_) {
this.append("default");
}
visitAggregateFunction(node) {
this.append(node.func);
this.append("(");
if (node.distinct) {
this.append("distinct ");
}
this.compileList(node.aggregated);
if (node.orderBy) {
this.append(" ");
this.visitNode(node.orderBy);
}
this.append(")");
if (node.withinGroup) {
this.append(" within group (");
this.visitNode(node.withinGroup);
this.append(")");
}
if (node.filter) {
this.append(" filter(");
this.visitNode(node.filter);
this.append(")");
}
if (node.over) {
this.append(" ");
this.visitNode(node.over);
}
}
visitOver(node) {
this.append("over(");
if (node.partitionBy) {
this.visitNode(node.partitionBy);
if (node.orderBy) {
this.append(" ");
}
}
if (node.orderBy) {
this.visitNode(node.orderBy);
}
this.append(")");
}
visitPartitionBy(node) {
this.append("partition by ");
this.compileList(node.items);
}
visitPartitionByItem(node) {
this.visitNode(node.partitionBy);
}
visitBinaryOperation(node) {
this.visitNode(node.leftOperand);
this.append(" ");
this.visitNode(node.operator);
this.append(" ");
this.visitNode(node.rightOperand);
}
visitUnaryOperation(node) {
this.visitNode(node.operator);
if (!this.isMinusOperator(node.operator)) {
this.append(" ");
}
this.visitNode(node.operand);
}
isMinusOperator(node) {
return OperatorNode.is(node) && node.operator === "-";
}
visitUsing(node) {
this.append("using ");
this.compileList(node.tables);
}
visitFunction(node) {
this.append(node.func);
this.append("(");
this.compileList(node.arguments);
this.append(")");
}
visitCase(node) {
this.append("case");
if (node.value) {
this.append(" ");
this.visitNode(node.value);
}
if (node.when) {
this.append(" ");
this.compileList(node.when, " ");
}
if (node.else) {
this.append(" else ");
this.visitNode(node.else);
}
this.append(" end");
if (node.isStatement) {
this.append(" case");
}
}
visitWhen(node) {
this.append("when ");
this.visitNode(node.condition);
if (node.result) {
this.append(" then ");
this.visitNode(node.result);
}
}
visitJSONReference(node) {
this.visitNode(node.reference);
this.visitNode(node.traversal);
}
visitJSONPath(node) {
if (node.inOperator) {
this.visitNode(node.inOperator);
}
this.append("'$");
for (const pathLeg of node.pathLegs) {
this.visitNode(pathLeg);
}
this.append("'");
}
visitJSONPathLeg(node) {
const isArrayLocation = node.type === "ArrayLocation";
const value = String(node.value);
if (isArrayLocation) {
this.append("[");
this.append(this.sanitizeStringLiteral(value));
this.append("]");
} else {
this.append('."');
this.append(this.sanitizeJSONPathMemberValue(value));
this.append('"');
}
}
visitJSONOperatorChain(node) {
for (let i = 0, len = node.values.length;i < len; i++) {
if (i === len - 1) {
this.visitNode(node.operator);
} else {
this.append("->");
}
this.visitNode(node.values[i]);
}
}
visitMergeQuery(node) {
if (node.with) {
this.visitNode(node.with);
this.append(" ");
}
this.append("merge ");
if (node.top) {
this.visitNode(node.top);
this.append(" ");
}
this.append("into ");
this.visitNode(node.into);
if (node.using) {
this.append(" ");
this.visitNode(node.using);
}
if (node.whens) {
this.append(" ");
this.compileList(node.whens, " ");
}
if (node.returning) {
this.append(" ");
this.visitNode(node.returning);
}
if (node.output) {
this.append(" ");
this.visitNode(node.output);
}
if (node.endModifiers?.length) {
this.append(" ");
this.compileList(node.endModifiers, " ");
}
}
visitMatched(node) {
if (node.not) {
this.append("not ");
}
this.append("matched");
if (node.bySource) {
this.append(" by source");
}
}
visitAddIndex(node) {
if (!this.parentNode || !CreateTableNode.is(this.parentNode)) {
this.append("add ");
}
if (node.unique) {
this.append("unique ");
}
this.append("index ");
this.visitNode(node.name);
if (node.columns) {
this.append(" (");
this.compileList(node.columns);
this.append(")");
}
if (node.using) {
this.append(" using ");
this.visitNode(node.using);
}
}
visitCast(node) {
this.append("cast(");
this.visitNode(node.expression);
this.append(" as ");
this.visitNode(node.dataType);
this.append(")");
}
visitFetch(node) {
this.append("fetch next ");
this.visitNode(node.rowCount);
this.append(` rows ${node.modifier}`);
}
visitOutput(node) {
this.append("output ");
this.compileList(node.selections);
}
visitTop(node) {
this.append(`top(${node.expression})`);
if (node.modifiers) {
this.append(` ${node.modifiers}`);
}
}
visitOrAction(node) {
this.append(node.action);
}
visitCollate(node) {
this.append("collate ");
this.visitNode(node.collation);
}
append(str) {
this.#sql += str;
}
appendValue(parameter) {
this.addParameter(parameter);
this.append(this.getCurrentParameterPlaceholder());
}
getLeftIdentifierWrapper() {
return '"';
}
getRightIdentifierWrapper() {
return '"';
}
getCurrentParameterPlaceholder() {
return "$" + this.numParameters;
}
getLeftExplainOptionsWrapper() {
return "(";
}
getExplainOptionAssignment() {
return " ";
}
getExplainOptionsDelimiter() {
return ", ";
}
getRightExplainOptionsWrapper() {
return ")";
}
sanitizeIdentifier(identifier) {
const leftWrap = this.getLeftIdentifierWrapper();
const rightWrap = this.getRightIdentifierWrapper();
let sanitized = "";
for (const c of identifier) {
sanitized += c;
if (c === leftWrap) {
sanitized += leftWrap;
} else if (c === rightWrap) {
sanitized += rightWrap;
}
}
return sanitized;
}
sanitizeStringLiteral(value) {
return value.replace(LIT_WRAP_REGEX, "''");
}
sanitizeJSONPathMemberValue(value) {
return value.replace(JSON_PATH_MEMBER_WRAP_REGEX, (char) => char === "'" ? "''" : "\\\"");
}
addParameter(parameter) {
this.#parameters.push(parameter);
}
appendImmediateValue(value) {
if (isString(value)) {
this.appendStringLiteral(value);
} else if (isNumber(value) || isBoolean(value) || isBigInt(value)) {
this.append(value.toString());
} else if (isNull(value)) {
this.append("null");
} else if (isDate(value)) {
this.appendImmediateValue(value.toISOString());
} else {
throw new Error(`invalid immediate value ${value}`);
}
}
appendStringLiteral(value) {
this.append("'");
this.append(this.sanitizeStringLiteral(value));
this.append("'");
}
sortSelectModifiers(arr) {
return freeze(arr.toSorted((left, right) => left.modifier && right.modifier ? SELECT_MODIFIER_PRIORITY[left.modifier] - SELECT_MODIFIER_PRIORITY[right.modifier] : 1));
}
compileColumnAlterations(columnAlterations) {
this.compileList(columnAlterations);
}
announcesNewColumnDataType() {
return true;
}
}
var SELECT_MODIFIER_SQL = freeze({
ForKeyShare: "for key share",
ForNoKeyUpdate: "for no key update",
ForUpdate: "for update",
ForShare: "for share",
NoWait: "nowait",
SkipLocked: "skip locked",
Distinct: "distinct"
});
var SELECT_MODIFIER_PRIORITY = freeze({
ForKeyShare: 1,
ForNoKeyUpdate: 1,
ForUpdate: 1,
ForShare: 1,
NoWait: 2,
SkipLocked: 2,
Distinct: 0
});
var JOIN_TYPE_SQL = freeze({
InnerJoin: "inner join",
LeftJoin: "left join",
RightJoin: "right join",
FullJoin: "full join",
CrossJoin: "cross join",
LateralInnerJoin: "inner join lateral",
LateralLeftJoin: "left join lateral",
LateralCrossJoin: "cross join lateral",
OuterApply: "outer apply",
CrossApply: "cross apply",
Using: "using"
});
// server/node_modules/kysely/dist/query-compiler/compiled-query.js
var CompiledQuery = freeze({
raw(sql2, parameters = []) {
return freeze({
sql: sql2,
query: RawNode.createWithSql(sql2),
parameters: freeze(parameters),
queryId: createQueryId()
});
}
});
// server/node_modules/kysely/dist/dialect/dialect-adapter-base.js
class DialectAdapterBase {
get supportsCreateIfNotExists() {
return true;
}
get supportsMultipleConnections() {
return true;
}
get supportsTransactionalDdl() {
return false;
}
get supportsReturning() {
return false;
}
get supportsOutput() {
return false;
}
}
// server/node_modules/kysely/dist/parser/savepoint-parser.js
function parseSavepointCommand(command, savepointName) {
return RawNode.createWithChildren([
RawNode.createWithSql(`${command} `),
IdentifierNode.create(savepointName)
]);
}
// server/node_modules/kysely/dist/dialect/sqlite/sqlite-driver.js
class SqliteDriver {
#config;
#db;
#connection;
constructor(config) {
this.#config = freeze({ ...config });
}
async init(options) {
this.#db = isFunction(this.#config.database) ? await this.#config.database(options) : this.#config.database;
this.#connection = new SqliteConnection(this.#db);
if (this.#config.onCreateConnection) {
await this.#config.onCreateConnection(this.#connection, options);
}
}
async acquireConnection() {
return this.#connection;
}
async beginTransaction(connection) {
await connection.executeQuery(CompiledQuery.raw("begin"));
}
async commitTransaction(connection) {
await connection.executeQuery(CompiledQuery.raw("commit"));
}
async rollbackTransaction(connection) {
await connection.executeQuery(CompiledQuery.raw("rollback"));
}
async savepoint(connection, savepointName, compileQuery) {
await connection.executeQuery(compileQuery(parseSavepointCommand("savepoint", savepointName), createQueryId()));
}
async rollbackToSavepoint(connection, savepointName, compileQuery) {
await connection.executeQuery(compileQuery(parseSavepointCommand("rollback to", savepointName), createQueryId()));
}
async releaseSavepoint(connection, savepointName, compileQuery) {
await connection.executeQuery(compileQuery(parseSavepointCommand("release", savepointName), createQueryId()));
}
async releaseConnection() {}
async destroy() {
this.#db?.close();
}
}
class SqliteConnection {
#db;
constructor(db) {
this.#db = db;
}
async executeQuery(compiledQuery) {
const { sql: sql2, parameters } = compiledQuery;
const stmt = this.#db.prepare(sql2);
if (stmt.reader) {
return {
rows: stmt.all(parameters)
};
}
const { changes, lastInsertRowid } = stmt.run(parameters);
return {
insertId: lastInsertRowid != null ? BigInt(lastInsertRowid) : undefined,
numAffectedRows: changes != null ? BigInt(changes) : undefined,
rows: []
};
}
async* streamQuery(compiledQuery, _chunkSize) {
const { sql: sql2, parameters, query } = compiledQuery;
const stmt = this.#db.prepare(sql2);
if (!SelectQueryNode.is(query)) {
throw new Error("Sqlite driver only supports streaming of select queries");
}
const iter = stmt.iterate(parameters);
for (const row of iter) {
yield {
rows: [row]
};
}
}
}
// server/node_modules/kysely/dist/dialect/sqlite/sqlite-query-compiler.js
var ID_WRAP_REGEX = /"/g;
var JSON_PATH_MEMBER_ESCAPE_REGEX = /[\\'"]/g;
class SqliteQueryCompiler extends DefaultQueryCompiler {
visitOrAction(node) {
this.append("or ");
this.append(node.action);
}
getCurrentParameterPlaceholder() {
return "?";
}
getLeftExplainOptionsWrapper() {
return "";
}
getRightExplainOptionsWrapper() {
return "";
}
getLeftIdentifierWrapper() {
return '"';
}
getRightIdentifierWrapper() {
return '"';
}
getAutoIncrement() {
return "autoincrement";
}
sanitizeIdentifier(identifier) {
return identifier.replace(ID_WRAP_REGEX, '""');
}
sanitizeJSONPathMemberValue(value) {
return value.replace(JSON_PATH_MEMBER_ESCAPE_REGEX, (char) => char === "\\" ? "\\\\" : char === "'" ? "''" : "\\\"");
}
visitDefaultInsertValue(_) {
this.append("null");
}
}
// server/node_modules/kysely/dist/migration/migrator.js
var DEFAULT_MIGRATION_TABLE = "kysely_migration";
var DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
var NO_MIGRATIONS = freeze({ __noMigrations__: true });
// server/node_modules/kysely/dist/dialect/sqlite/sqlite-introspector.js
class SqliteIntrospector {
#db;
constructor(db) {
this.#db = db;
}
async getSchemas() {
return [];
}
async getTables(options = { withInternalKyselyTables: false }) {
return await this.#getTableMetadata(options);
}
#tablesQuery(qb, options) {
let tablesQuery = qb.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select(["name", "sql", "type"]).orderBy("name");
if (!options.withInternalKyselyTables) {
tablesQuery = tablesQuery.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
}
return tablesQuery;
}
async#getTableMetadata(options) {
const tablesResult = await this.#tablesQuery(this.#db, options).execute();
const tableMetadata = await this.#db.with("table_list", (qb) => this.#tablesQuery(qb, options)).selectFrom([
"table_list as tl",
sql`pragma_table_info(tl.name)`.as("p")
]).select([
"tl.name as table",
"p.cid",
"p.name",
"p.type",
"p.notnull",
"p.dflt_value",
"p.pk"
]).orderBy("tl.name").orderBy("p.cid").execute();
const columnsByTable = {};
for (const row of tableMetadata) {
columnsByTable[row.table] ??= [];
columnsByTable[row.table].push(row);
}
return tablesResult.map(({ name, sql: sql2, type }) => {
let autoIncrementCol = sql2?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
const columns = columnsByTable[name] ?? [];
if (!autoIncrementCol) {
const pkCols = columns.filter((r) => r.pk > 0);
if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === "integer") {
autoIncrementCol = pkCols[0].name;
}
}
return {
name,
isView: type === "view",
isForeign: false,
columns: columns.map((col) => ({
name: col.name,
dataType: col.type,
isNullable: !col.notnull,
isAutoIncrementing: col.name === autoIncrementCol,
hasDefaultValue: col.dflt_value != null,
comment: undefined
}))
};
});
}
}
// server/node_modules/kysely/dist/dialect/sqlite/sqlite-adapter.js
class SqliteAdapter extends DialectAdapterBase {
get supportsMultipleConnections() {
return false;
}
get supportsTransactionalDdl() {
return false;
}
get supportsReturning() {
return true;
}
async acquireMigrationLock(_db, _opt) {}
async releaseMigrationLock(_db, _opt) {}
}
// server/node_modules/kysely/dist/dialect/sqlite/sqlite-dialect.js
class SqliteDialect {
#config;
constructor(config) {
this.#config = freeze({ ...config });
}
createDriver() {
return new SqliteDriver(this.#config);
}
createQueryCompiler() {
return new SqliteQueryCompiler;
}
createAdapter() {
return new SqliteAdapter;
}
createIntrospector(db) {
return new SqliteIntrospector(db);
}
}
// server/node_modules/kysely/dist/plugin/parse-json-results/parse-json-results-plugin.js
class ParseJSONResultsPlugin {
options;
#options;
constructor(options = {}) {
this.options = options;
const { shouldParse } = options;
this.#options = freeze({
objectStrategy: options.objectStrategy || "in-place",
reviver: options.reviver || ((_, value) => value),
shouldParse: shouldParse ? (value, jsonPath) => maybeJson(value) && shouldParse(value, jsonPath) : maybeJson
});
}
transformQuery(args) {
return args.node;
}
async transformResult(args) {
return {
...args.result,
rows: parseArray(args.result.rows, "$", this.#options)
};
}
}
function parseArray(arr, jsonPath, options) {
const target = options.objectStrategy === "create" ? new Array(arr.length) : arr;
for (let i = 0;i < arr.length; ++i) {
target[i] = parse(arr[i], `${jsonPath}[${i}]`, options);
}
return target;
}
function parse(value, jsonPath, options) {
if (isString(value)) {
return parseString(value, jsonPath, options);
}
if (Array.isArray(value)) {
return parseArray(value, jsonPath, options);
}
if (isPlainObject(value)) {
return parseObject(value, jsonPath, options);
}
return value;
}
function parseString(str, jsonPath, options) {
const { shouldParse } = options;
if (!shouldParse(str, jsonPath)) {
return str;
}
try {
return parse(JSON.parse(str, (key, value, ...otherArgs) => {
if (key === "__proto__") {
return;
}
if (key === "constructor" && isPlainObject(value) && Object.hasOwn(value, "prototype")) {
delete value.prototype;
}
return options.reviver(key, value, ...otherArgs);
}), jsonPath, { ...options, objectStrategy: "in-place" });
} catch (error) {
if (shouldParse !== maybeJson) {
throw error;
}
console.error(error);
return str;
}
}
function maybeJson(value) {
return value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]");
}
function parseObject(obj, jsonPath, options) {
const { objectStrategy } = options;
const target = objectStrategy === "create" ? {} : obj;
for (const key of Object.keys(obj)) {
if (key === "__proto__") {
continue;
}
const parsed = parse(obj[key], `${jsonPath}."${key}"`, options);
if (key === "constructor" && isPlainObject(parsed) && Object.hasOwn(parsed, "prototype")) {
delete parsed.prototype;
}
target[key] = parsed;
}
return target;
}
// server/src/kysely-node-sqlite.ts
var plain = (row) => {
const out = {};
for (const [k, v] of Object.entries(row))
out[k] = v instanceof Uint8Array && !Buffer.isBuffer(v) ? Buffer.from(v.buffer, v.byteOffset, v.byteLength) : v;
return out;
};
function adapt(raw) {
return {
prepare(sqlText) {
const st = raw.prepare(sqlText);
const args = (p) => p;
return {
get reader() {
return st.columns().length > 0;
},
all: (p) => st.all(...args(p)).map(plain),
run: (p) => {
const r = st.run(...args(p));
return { changes: r.changes, lastInsertRowid: r.lastInsertRowid };
},
iterate: (p) => st.iterate(...args(p))
};
},
close: () => raw.close()
};
}
// server/src/sqlite.ts
import fs4 from "node:fs";
import os2 from "node:os";
import path4 from "node:path";
import { constants as C, DatabaseSync } from "node:sqlite";
// server/src/plugin.ts
import fs3 from "node:fs";
import path3 from "node:path";
import { fileURLToPath } from "node:url";
// server/node_modules/smol-toml/dist/error.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/primitive.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/date.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/extract.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/util.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/struct.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/parse.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/node_modules/smol-toml/dist/stringify.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
var HAS_WELLFORMED = !!"".isWellFormed;
// server/node_modules/smol-toml/dist/index.js
/*!
* Copyright (c) Squirrel Chat et al., All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// server/src/codex-trust.ts
var NO_MATCHER = new Set(["UserPromptSubmit", "Stop", "Interrupt"]);
var CONTEXT = new Set(["PreToolUse", "PostToolUse", "SessionStart", "UserPromptSubmit", "SubagentStart"]);
var SHORT = new Set(["SessionEnd", "Interrupt"]);
// server/src/git.ts
import { execFileSync, spawn } from "node:child_process";
import fs2 from "node:fs";
import os from "node:os";
import path2 from "node:path";
var gitHome = () => path2.join(os.homedir(), ".sphica", "git");
function gitEnv(extra = {}) {
const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^GIT_/i.test(k)));
return {
...env,
GIT_ALLOW_PROTOCOL: "",
GIT_NO_LAZY_FETCH: "1",
GIT_TERMINAL_PROMPT: "0",
GIT_NO_REPLACE_OBJECTS: "1",
...extra
};
}
var gitOptions = (hooks = path2.join(gitHome(), "hooks")) => [
"-c",
"core.fsmonitor=",
"-c",
`core.hooksPath=${hooks}`,
"-c",
"core.quotePath=false",
"--no-pager",
"--no-optional-locks"
];
var DIFF_OPTIONS = [
"--no-color",
"--no-ext-diff",
"--no-textconv",
"--ignore-submodules=dirty",
"--submodule=short"
];
function startDir() {
const home = os.homedir();
return fs2.statSync(home, { throwIfNoEntry: false })?.isDirectory() ? home : path2.dirname(process.execPath);
}
function run(root, args, { max = 1024 * 1024, timeout = 1e4 } = {}) {
return execFileSync("git", ["-C", root, ...gitOptions(), ...args], {
cwd: startDir(),
env: gitEnv(),
maxBuffer: max,
stdio: ["ignore", "pipe", "ignore"],
timeout,
killSignal: "SIGKILL"
});
}
var text2 = (root, args, limits) => run(root, args, limits).toString("utf8");
var list = (out) => out.split("\x00").filter(Boolean);
function revision(rev) {
if (!rev || rev.startsWith("-") || /[\0\n]/.test(rev))
throw new Error(`not a revision: ${JSON.stringify(rev)}`);
return rev;
}
function objectId(oid) {
if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(oid))
throw new Error(`not an object id: ${JSON.stringify(oid)}`);
return oid;
}
var topLevel = (dir, limits) => text2(dir, ["rev-parse", "--show-toplevel"], limits).trim();
var commitOf = (root, rev, limits) => text2(root, ["rev-parse", "--verify", "-q", `${revision(rev)}^{commit}`], limits).trim();
function isAncestor(root, a, b, limits) {
try {
run(root, ["merge-base", "--is-ancestor", objectId(a), objectId(b)], limits);
return true;
} catch {
return false;
}
}
var commitDiffNames = (root, a, b, limits) => list(text2(root, ["diff", ...DIFF_OPTIONS, "--name-only", "-z", objectId(a), objectId(b), "--"], limits));
var originUrl = (root, limits) => text2(root, ["remote", "get-url", "origin"], limits).trim();
async function worktreeStatus(root, deadline) {
const out = await inIsolation(root, [{ kind: "status" }], { deadline, max: 16 * 1024 * 1024 });
return Array.isArray(out) ? out[0] ?? null : null;
}
function workerFile() {
const js = path2.join(import.meta.dirname, "git-worker.js");
return fs2.existsSync(js) ? js : path2.join(import.meta.dirname, "git-worker.ts");
}
function inIsolation(root, ops, { deadline, max }) {
return new Promise((resolve) => {
let child;
try {
child = spawn(process.execPath, [workerFile()], {
cwd: startDir(),
stdio: ["pipe", "pipe", "ignore"],
windowsHide: true,
detached: process.platform !== "win32"
});
} catch {
resolve({ unread: "failed" });
return;
}
const chunks = [];
let size = 0;
let done = false;
const finish = (out) => {
if (done)
return;
done = true;
clearTimeout(timer);
if (!Array.isArray(out)) {
try {
if (process.platform !== "win32" && child.pid)
process.kill(-child.pid, "SIGKILL");
else
child.kill("SIGKILL");
} catch {
child.kill("SIGKILL");
}
child.stdin?.destroy();
child.stdout?.destroy();
child.unref();
}
resolve(out);
};
const timer = setTimeout(() => finish({ unread: "timeout" }), deadline);
const cap = 6 * max * Math.max(1, ops.length * 2) + 64 * 1024;
child.stdout?.on("data", (c) => {
size += c.length;
if (size > cap)
finish({ unread: "too_large" });
else
chunks.push(c);
});
child.on("error", () => finish({ unread: "failed" }));
child.on("close", () => {
try {
const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
if (result.ok)
finish(result.out);
else if ("refused" in result)
finish({ unread: "refused", code: result.refused });
else
finish({ unread: result.failed });
} catch {
finish({ unread: "failed" });
}
});
child.stdin?.on("error", () => finish({ unread: "failed" }));
child.stdin?.end(JSON.stringify({
root,
ops,
max,
until: Date.now() + Math.floor(deadline * 0.8)
}));
});
}
// server/src/panel.ts
import { stripVTControlCharacters, styleText } from "node:util";
// server/src/text.ts
import crypto from "node:crypto";
var segmenter = new Intl.Segmenter("ja", { granularity: "word" });
var HIRAGANA_ONLY = /^[\p{Script=Hiragana}ー]+$/u;
var STOP = new Set(["the", "a", "an", "of", "to", "in", "is", "and", "or", "for", "on", "it", "be"]);
var IDENT = /#\d+|[a-z0-9][a-z0-9_./#-]*[a-z0-9]/g;
var WORD = /[\p{L}\p{M}\p{N}_]+/gu;
var JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]+/u;
var COMPOUND = /^[A-Za-z0-9_]*(?:[A-Za-z0-9]_|_[A-Za-z0-9]|[a-z0-9][A-Z])[A-Za-z0-9_]*$/;
var CUT = /_+|(?<=[a-z0-9])(?=[A-Z])/;
var MAX_PARTS = 6;
var NAME_PART = /^(?:[A-Za-z]+[0-9]*|[0-9]+)$/;
var MAX_TERM = 100;
var OKURIGANA = /^(\p{Script=Han}+)[\p{Script=Hiragana}ー]+$/u;
function singular(w) {
if (!/^[a-z]{4,}$/.test(w))
return w;
if (w.endsWith("ies"))
return `${w.slice(0, -3)}y`;
if (w.endsWith("ie"))
return `${w.slice(0, -2)}y`;
if (/(?:ss|us|x|z|ch|sh)es$/.test(w))
return w.slice(0, -2);
if (/(?:ch|sh|us)e$/.test(w))
return w.slice(0, -1);
return w.endsWith("s") && !/(?:ss|us|is)$/.test(w) ? w.slice(0, -1) : w;
}
function terms(text3, parts = true) {
const nfkc = text3.normalize("NFKC");
const norm = nfkc.toLowerCase();
const out = [];
const keep = (w) => {
if (w.length > MAX_TERM || STOP.has(w) || HIRAGANA_ONLY.test(w))
return;
out.push(OKURIGANA.exec(w)?.[1] ?? singular(w));
};
for (const s of segmenter.segment(norm))
if (s.isWordLike)
keep(s.segment.trim());
for (const m of norm.matchAll(IDENT))
if (m[0].length >= 3)
keep(m[0]);
if (parts)
for (const [word] of nfkc.matchAll(WORD))
for (const w of word.split(JAPANESE)) {
if (w.length > MAX_TERM || !COMPOUND.test(w))
continue;
const cut = w.split(CUT).filter(Boolean);
if (cut.length <= MAX_PARTS && cut.every((p) => NAME_PART.test(p))) {
for (const p of cut)
if (p.length >= 2)
keep(p.toLowerCase());
}
}
return out.filter(Boolean);
}
var QUESTION = new Set([
...[
"why",
"what",
"which",
"when",
"where",
"who",
"how",
"do",
"does",
"did",
"we",
"our",
"us",
"you",
"i",
"are",
"was",
"were"
],
...[
"will",
"would",
"should",
"can",
"could",
"there",
"this",
"that",
"with",
"from",
"any",
"ever",
"long",
"use",
"used",
"using"
],
...["add", "get", "make", "have", "has", "not", "no", "yes", "reason"],
...["理由", "仕組", "何", "方", "場合", "今", "件"]
]);
var FOLDED_QUESTION = new Set([...QUESTION].flatMap((w) => terms(w)));
var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
function uuidFrom(...parts) {
const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
b[6] = (b[6] ?? 0) & 15 | 128;
b[8] = (b[8] ?? 0) & 63 | 128;
const h = b.toString("hex");
return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
}
var bytes = (s) => Buffer.byteLength(s, "utf8");
function head(s, n) {
if (bytes(s) <= n)
return s;
let out = "";
let used = 0;
for (const ch of s) {
const b = bytes(ch);
if (used + b > n)
break;
out += ch;
used += b;
}
return out;
}
function tail(s, n) {
if (bytes(s) <= n)
return s;
const chars = [...s];
let used = 0;
let i = chars.length;
while (i > 0) {
const b = bytes(chars[i - 1] ?? "");
if (used + b > n)
break;
used += b;
i--;
}
return chars.slice(i).join("");
}
var clean = (s) => s.replaceAll("\x00", "");
var visible = (s) => s.replace(/(?!\p{Join_Control}|\p{Variation_Selector})\p{Default_Ignorable_Code_Point}/gu, "");
var SECRETS = [
[/\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}/g, "API key"],
[/\b[srp]k_(?:live|test)_[A-Za-z0-9]{16,}/g, "API key"],
[/\bwhsec_[A-Za-z0-9+/=]{16,}/g, "webhook signing secret"],
[/\bpa-[A-Za-z0-9_-]{20,}/g, "API key"],
[/\bAIza[0-9A-Za-z_-]{35}/g, "API key"],
[/\bnpg_[A-Za-z0-9]{12,}/g, "database password"],
[/\bnapi_[A-Za-z0-9]{30,}/g, "API key"],
[/\bnpm_[A-Za-z0-9]{36}\b/g, "npm token"],
[/\bglpat-[A-Za-z0-9_-]{20,}/g, "GitLab token"],
[
/(?<![A-Za-z0-9])ghs_eyJ[A-Za-z0-9_-]{5,200}\.[A-Za-z0-9_-]{8,2000}\.[A-Za-z0-9_-]{8,1000}/g,
"GitHub token"
],
[/(?<![A-Za-z0-9])gh[pousr]_[A-Za-z0-9]{30,}/g, "GitHub token"],
[/(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{40,}/g, "GitHub token"],
[/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "Slack token"],
[/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/]+/g, "Slack webhook"],
[/\bAKIA[0-9A-Z]{16}\b/g, "AWS key"],
[/(?<![A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "JWT"],
[/\b(?:Bearer|BEARER)\s+(?=[A-Za-z0-9._~+/=-]{0,512}\d)[A-Za-z0-9._~+/=-]{16,}/g, "auth header value"]
];
var AUTH_HEADER = /(\bAuthorization["']?\s*[:=]\s*(?:["']\s*)?(?:Bearer|Basic|Token|Digest)\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
var HEADER_BEARER = /(:[ \t]*(?:["'][ \t]*)?bearer[ \t]+)[A-Za-z0-9._~+/=-]{16,}/gi;
var ENV_ASSIGN = /\b((?:[A-Z][A-Z0-9_]*_)?(?:API|SECRET|MASTER|ENCRYPTION|PRIVATE|ACCESS|SIGNING|AUTH)?KEY|[A-Z][A-Z0-9_]*_(?:PASS|PWD)|(?:[A-Z][A-Z0-9_]*?)?(?:TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?))(\s*=\s*)(?:"(?!\$)[^"\n]+"|'(?!\$)[^'\n]+'|(?![$"'])[^\s"']+)/g;
var FIELD_NAME = /(?:(?:api|account|access|private|secret)[-_]?key|secret|token|passw(?:or)?d)["']?\s*(?::=|=>|[:=])\s*/gi;
var MAX_QUOTED = 4096;
var BARE_HEAD = /[^\s"',;)]{1,256}/y;
var BARE_REST = /[^\s"',;)]*/y;
var NEXT_PARAM = /&[A-Za-z_][\w.-]*=/;
var bareAt = (re, text3, at) => {
re.lastIndex = at;
const v = re.exec(text3)?.[0] ?? "";
const cut = v.search(NEXT_PARAM);
return cut < 0 ? v : v.slice(0, cut);
};
function secretValue(quoted, v) {
if (v.length < 8 || /^\$(?:\{|[A-Za-z_])/.test(v))
return false;
if (!quoted)
return !/^[#$]/.test(v) && /\d/.test(v) && /[A-Za-z]/.test(v) && !/[()]/.test(v);
if (/^#[0-9a-f]{3,8}$/i.test(v) || !/[A-Za-z0-9]/.test(v))
return false;
return !/\s/.test(v) || v.split(/\s+/).some((w) => /\d/.test(w) && /[A-Za-z]/.test(w));
}
function maskFields(text3) {
let out = "";
let last = 0;
FIELD_NAME.lastIndex = 0;
for (let m = FIELD_NAME.exec(text3);m; m = FIELD_NAME.exec(text3)) {
const at = m.index + m[0].length;
const q = text3[at];
let quote = "";
let value;
if (q === '"' || q === "'") {
const close = text3.indexOf(q, at + 1);
if (close < 0 || close - at - 1 > MAX_QUOTED)
continue;
value = text3.slice(at + 1, close);
if (value.includes(`
`))
continue;
quote = q;
} else {
value = bareAt(BARE_HEAD, text3, at);
}
if (!secretValue(quote !== "", value))
continue;
if (!quote && value.length === 256)
value += bareAt(BARE_REST, text3, at + 256);
out += `${text3.slice(last, at)}${quote}[redacted]`;
last = at + quote.length + value.length;
FIELD_NAME.lastIndex = last;
}
return out + text3.slice(last);
}
var MYSQL_COMMAND = /\bmysql(?:dump|admin)?\b(?:'[^'\n]*'|"[^"\n]*"|[^\n;&|\\'"]|\\\r?\n|\\(?!\r?\n))*/g;
var MYSQL_PASSWORD = /(\s-p)(?:'[^'\n]*'|"[^"\n]*"|(?=[^\s-])\S+)/;
var URL_CREDENTIALS = /\b((?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqps?|https?):\/\/[^:\s/@]*:)[^\s/]*@([^@\s/?#]+)/g;
var KEY_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
var KEY_END = /-----END [A-Z ]*PRIVATE KEY-----/g;
function keyBlocks(text3) {
const ends = [...text3.matchAll(KEY_END)].map((m) => [m.index, m.index + m[0].length]);
const out = [];
let last = 0;
let e = 0;
if (ends.length > 0)
for (const m of text3.matchAll(KEY_BEGIN)) {
const after = m.index + m[0].length;
if (m.index < last)
continue;
while (e < ends.length && (ends[e]?.[0] ?? 0) < after)
e++;
const end = ends[e];
if (!end)
break;
out.push([m.index, end[1]]);
last = end[1];
}
return out;
}
function maskPrivateKeys(text3) {
let out = "";
let last = 0;
for (const [a, b] of keyBlocks(text3)) {
out += `${text3.slice(last, a)}[redacted: private key]`;
last = b;
}
return out + text3.slice(last);
}
function mask(text3) {
let out = maskFields(maskPrivateKeys(text3).replace(URL_CREDENTIALS, "$1[redacted]@$2").replace(AUTH_HEADER, "$1[redacted]").replace(HEADER_BEARER, "$1[redacted]").replace(ENV_ASSIGN, "$1$2[redacted]")).replace(MYSQL_COMMAND, (command) => command.replace(MYSQL_PASSWORD, "$1[redacted]"));
for (const [re, what] of SECRETS)
out = out.replace(re, `[redacted: ${what}]`);
return out;
}
var reason = (e) => explain(e, 0) || "unknown failure";
var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
function explain(e, depth) {
if (!(e instanceof Error)) {
try {
return String(e);
} catch {
return "";
}
}
const own = e.message || (e.name === "Error" || e.name === "AggregateError" ? "" : e.name);
const parts = depth >= 3 ? [] : [...e instanceof AggregateError ? e.errors : [], ...e.cause === undefined ? [] : [e.cause]];
const inner = parts.map((x) => explain(x, depth + 1)).filter(Boolean).join(" / ");
return own && inner ? `${own} (${inner})` : own || inner;
}
// server/src/panel.ts
var title = (text3) => `✦ ${text3}`;
var rule = (text3) => text3.split(`
`).map((line) => line ? `│ ${line}` : "│").join(`
`);
var foot = (text3) => `╰─ ${text3}`;
var panel = (head2, lines, end) => [title(head2), ...lines.map(rule), foot(end)].join(`
`);
var STRING_SEQUENCE = /\u001b[\]P_^X][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g;
var plain2 = (s) => visible(stripVTControlCharacters(s.replace(STRING_SEQUENCE, "")).replace(/\r\n?|[\v\f\u0085\p{Zl}\p{Zp}]/gu, `
`).replace(/(?![\t\n])\p{Cc}/gu, ""));
// server/src/plugin.ts
var MANIFEST = path3.join(".claude-plugin", "plugin.json");
var PACKAGE = "package.json";
function versionAt(root) {
try {
const m = JSON.parse(fs3.readFileSync(path3.join(root, MANIFEST), "utf8"));
return m.name === "sphica" && typeof m.version === "string" ? m.version : null;
} catch {
return null;
}
}
function packageVersionAt(root) {
try {
const m = JSON.parse(fs3.readFileSync(path3.join(root, PACKAGE), "utf8"));
return m.name === "sphica" && typeof m.version === "string" ? m.version : null;
} catch {
return null;
}
}
var here = path3.dirname(fileURLToPath(import.meta.url));
var ROOT = [path3.join(here, ".."), path3.join(here, "..", "..", "plugin")].find((r) => versionAt(r) !== null) ?? path3.join(here, "..");
var HOST_MARKS = new Set([".orphaned_at", ".in_use"]);
// server/src/sqlite.ts
var SCHEMA_GENERATION = 2;
var SCHEMA_REVISION = 14;
var sphicaHome = () => process.env.SPHICA_HOME || path4.join(os2.homedir(), ".sphica");
var dbFile = () => process.env.SPHICA_DB || path4.join(sphicaHome(), "sphica.db");
function requireRuntime() {
const proto = DatabaseSync.prototype;
if (typeof proto.setAuthorizer !== "function" || typeof proto.enableDefensive !== "function")
throw new Error(`Sphica needs Node 24.15 or later (this is ${process.version}). Upgrade Node.`);
}
function requireFile(file) {
if (!fs4.existsSync(file))
throw new Error(`No database at ${file}. Create it with \`sphica init\`.`);
}
function prepare(raw, check, busyMs = 5000) {
raw.enableDefensive(true);
raw.exec("pragma foreign_keys = on");
raw.exec(`pragma busy_timeout = ${Math.trunc(busyMs)}`);
if (check === "none")
return;
checkGeneration(raw);
if (check === "generation")
return;
requireRevision(raw);
}
function requireRevision(raw) {
const got = raw.prepare("pragma user_version").get()?.user_version;
if (got === SCHEMA_REVISION)
return;
throw new RevisionMismatch(got ?? 0);
}
class RevisionMismatch extends Error {
constructor(got) {
super(`The database schema is revision ${got}, but this Sphica expects revision ${SCHEMA_REVISION}. ` + (got < SCHEMA_REVISION ? `Run \`npm i -g sphica@${packageVersionAt(ROOT) ?? "latest"}\`, then \`sphica init\` to migrate it (records are kept, and a backup is made first).` : "Update sphica."));
}
}
function generationOf(raw) {
const has = raw.prepare("select 1 from sqlite_schema where type = 'table' and name = 'sphica_generation'").get();
if (!has) {
const any = raw.prepare("select 1 from sqlite_schema where type = 'table' and name = 'project'").get();
return any ? 1 : null;
}
return raw.prepare("select generation from sphica_generation").get()?.generation ?? null;
}
function checkGeneration(raw) {
const got = generationOf(raw);
if (got === SCHEMA_GENERATION)
return;
if (got === null)
throw new Error("The database has no sphica schema. Create it with `sphica init`.");
throw new Error(got < SCHEMA_GENERATION ? "The database was made by Sphica 0.4 or earlier, and this Sphica cannot read it. Move it aside (it is left unchanged), then run `sphica init`." : "The database was made by a newer Sphica. Update sphica.");
}
var READER_FUNCTIONS = new Set([
"bm25",
"coalesce",
"count",
"instr",
"json_array_length",
"json_extract",
"json_group_array",
"json_object",
"length",
"lower",
"match",
"max",
"min",
"substr"
]);
var SHADOW = /^(unit|source)_fts_(data|idx|docsize|config)$/;
// server/src/db.ts
var JSON_COLUMNS = new Set(["next"]);
var TOP_LEVEL = /^\$\[\d+\]\."([^"]+)"$/;
var parseJson = new ParseJSONResultsPlugin({
shouldParse: (_value, jsonPath) => JSON_COLUMNS.has(jsonPath.match(TOP_LEVEL)?.[1] ?? "")
});
function kyselyOn(connect) {
return new Kysely({
dialect: new SqliteDialect({ database: async () => adapt(connect()) }),
plugins: [parseJson]
});
}
async function inTransaction(db, fn) {
return db.connection().execute(async (c) => {
await sql`begin immediate`.execute(c);
try {
const out = await fn(c);
await sql`commit`.execute(c);
return out;
} catch (e) {
await sql`rollback`.execute(c).catch(() => {});
throw e;
}
});
}
var iso = (d) => {
const t = new Date(d);
if (Number.isNaN(t.getTime()))
throw new RangeError(`Not a readable time: ${String(d)}`);
return t.toISOString();
};
function sqliteCode(e) {
const x = e;
return x?.code === "ERR_SQLITE_ERROR" && typeof x.errcode === "number" ? x.errcode & 255 : null;
}
// server/src/db-write.ts
import { constants as C2, DatabaseSync as DatabaseSync2 } from "node:sqlite";
var ddl = null;
var DDL = () => ddl ??= new Set([
"SQLITE_ALTER_TABLE",
"SQLITE_ANALYZE",
"SQLITE_ATTACH",
"SQLITE_CREATE_INDEX",
"SQLITE_CREATE_TABLE",
"SQLITE_CREATE_TEMP_INDEX",
"SQLITE_CREATE_TEMP_TABLE",
"SQLITE_CREATE_TEMP_TRIGGER",
"SQLITE_CREATE_TEMP_VIEW",
"SQLITE_CREATE_TRIGGER",
"SQLITE_CREATE_VIEW",
"SQLITE_CREATE_VTABLE",
"SQLITE_DETACH",
"SQLITE_DROP_INDEX",
"SQLITE_DROP_TABLE",
"SQLITE_DROP_TEMP_INDEX",
"SQLITE_DROP_TEMP_TABLE",
"SQLITE_DROP_TEMP_TRIGGER",
"SQLITE_DROP_TEMP_VIEW",
"SQLITE_DROP_TRIGGER",
"SQLITE_DROP_VIEW",
"SQLITE_DROP_VTABLE",
"SQLITE_REINDEX"
].map((name) => {
const code = C2[name];
if (code === undefined)
throw new Error(`node:sqlite constants has no ${name}`);
return code;
}));
var readsDataVersion = (p1, p2) => p1 === "data_version" && p2 === null;
var CAPTURE_VIEWS = new Set([
"capture_session",
"capture_message",
"capture_edit",
"capture_tool_call",
"capture_delivery",
"capture_delivery_scoped",
"capture_delivery_prune"
]);
var TRIGGER_WRITES = {
capture_session_insert: new Set(["session"]),
capture_message_insert: new Set(["source"]),
capture_edit_insert: new Set(["edit_observation"]),
capture_tool_call_insert: new Set(["tool_call_observation"]),
capture_delivery_insert: new Set(["delivery", "delivery_unit"]),
capture_delivery_scoped_insert: new Set(["delivery", "delivery_unit"]),
source_fts_ai: new Set(["source_fts"])
};
var TRIGGER_DELETES = {
capture_delivery_prune_insert: new Set(["delivery"]),
delivery_ad: new Set(["delivery_unit"])
};
var TRIGGER_FUNCTIONS = {
capture_delivery_insert: new Set(["coalesce", "json_each", "last_insert_rowid"]),
capture_delivery_scoped_insert: new Set(["coalesce", "json_each", "last_insert_rowid"])
};
var CAPTURE_READS = {
project: new Set(["id", "key", "name"]),
session: new Set(["id"]),
source: new Set(["id", "session_id", "external_id", "kind"])
};
function captureAuthorizer(own, action, p1, p2, triggerOrView) {
const table = p1 ?? "";
const fts = SHADOW.test(table) && (!own || action === C2.SQLITE_READ && table.endsWith("_config"));
if (action === C2.SQLITE_INSERT) {
if (CAPTURE_VIEWS.has(table))
return C2.SQLITE_OK;
if (triggerOrView !== null && TRIGGER_WRITES[triggerOrView]?.has(table))
return C2.SQLITE_OK;
return fts ? C2.SQLITE_OK : C2.SQLITE_DENY;
}
if (action === C2.SQLITE_DELETE && triggerOrView !== null && TRIGGER_DELETES[triggerOrView]?.has(table))
return C2.SQLITE_OK;
if (action === C2.SQLITE_UPDATE || action === C2.SQLITE_DELETE)
return fts ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_READ) {
if (triggerOrView !== null || fts)
return C2.SQLITE_OK;
return CAPTURE_READS[table]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
}
if (action === C2.SQLITE_FUNCTION)
return p2 === "sphica_terms" || triggerOrView !== null && TRIGGER_FUNCTIONS[triggerOrView]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_PRAGMA)
return readsDataVersion(p1, p2) ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_SELECT || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
return C2.SQLITE_OK;
return C2.SQLITE_DENY;
}
var writes = (action) => action === C2.SQLITE_INSERT || action === C2.SQLITE_UPDATE || action === C2.SQLITE_DELETE;
var INGEST_INSERTS = new Set([
"project",
"record_call",
"ingest_source",
"extraction_run",
"source_processing",
"harvest_run_source",
"unit",
"unit_option",
"unit_evidence",
"unit_adoption",
"unit_link",
"unit_state",
"unit_answer",
"unit_replacement",
"unit_anchor",
"unit_anchor_retirement",
"unit_command",
"unit_alias",
"field_def",
"unit_field",
"work",
"artifact_link"
]);
var RETRACTION = [
"retracted_at",
"retraction_reason",
"retraction_source_id",
"retraction_span_start",
"retraction_span_end"
];
var INGEST_UPDATES = {
extraction_run: new Set(["status", "finished_at"]),
unit_anchor: new Set(["retired_at", "replaced_by"]),
unit_link: new Set(["resolved_at", "resolution"]),
unit_evidence: new Set(RETRACTION),
unit_adoption: new Set(RETRACTION),
unit_replacement: new Set(["ended_at", "end_reason", "end_run_id"]),
work: new Set(["title", "goal", "current", "next", "status", "branch", "run_id", "updated_at"])
};
var INGEST_DELETES = new Set(["artifact_link"]);
var INGEST_TRIGGER_WRITES = {
ingest_source_insert: ["insert source"],
source_fts_ai: ["insert source_fts"],
source_fts_ad: ["delete source_fts"],
unit_state_apply: ["update unit"],
delivery_ad: ["delete delivery_unit"],
...Object.fromEntries([
"evidence_i",
"evidence_u",
"evidence_d",
"adoption_i",
"adoption_u",
"adoption_d",
"link_i",
"link_u",
"answer_i",
"replacement_i",
"replacement_u",
"anchor_i",
"anchor_u",
"alias_i",
"field_i",
"field_d",
"retirement_i",
"retirement_d",
"command_i"
].map((t) => [`unit_rev_${t}`, ["update unit"]])),
unit_fts_ai: ["insert unit_fts"],
unit_fts_ad: ["delete unit_fts"],
...Object.fromEntries([
"option_i",
"anchor_i",
"anchor_u",
"anchor_d",
"command_i",
"alias_i",
"alias_d",
"field_i",
"field_d"
].map((t) => [`unit_fts_${t}`, ["delete unit_fts", "insert unit_fts"]]))
};
var opOf = (action) => action === C2.SQLITE_INSERT ? "insert" : action === C2.SQLITE_UPDATE ? "update" : action === C2.SQLITE_DELETE ? "delete" : undefined;
function ingestAuthorizer(action, p1, p2, trigger) {
if (DDL().has(action))
return C2.SQLITE_DENY;
const op = opOf(action);
if (op) {
const table = p1 ?? "";
if (SHADOW.test(table))
return C2.SQLITE_OK;
if (trigger !== null)
return INGEST_TRIGGER_WRITES[trigger]?.includes(`${op} ${table}`) ? C2.SQLITE_OK : C2.SQLITE_DENY;
const allowed = op === "insert" ? INGEST_INSERTS.has(table) : op === "update" ? INGEST_UPDATES[table]?.has(p2 ?? "") : INGEST_DELETES.has(table);
return allowed ? C2.SQLITE_OK : C2.SQLITE_DENY;
}
if (action === C2.SQLITE_PRAGMA)
return readsDataVersion(p1, p2) ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_READ || action === C2.SQLITE_SELECT || action === C2.SQLITE_FUNCTION || action === C2.SQLITE_RECURSIVE || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
return C2.SQLITE_OK;
return C2.SQLITE_DENY;
}
var FORGET_WRITES = {
[C2.SQLITE_INSERT]: new Set([
"forget_batch",
"source_forgotten",
"unit_state",
"unit_replacement",
"source_fts",
"unit_fts"
]),
[C2.SQLITE_DELETE]: new Set([
"source",
"unit_evidence",
"unit_adoption",
"source_processing",
"harvest_run_source",
"unit_anchor_retirement",
"source_fts",
"field_def",
"unit_field",
"unit_fts"
])
};
var FORGET_UPDATES = {
unit: new Set(["lifecycle", "revision"]),
unit_state: new Set(["source_id"]),
unit_replacement: new Set(["ended_at", "end_reason", "end_forget_id"])
};
function forgetAuthorizer(action, p1, p2) {
if (SHADOW.test(p1 ?? "") && writes(action))
return C2.SQLITE_OK;
if (action === C2.SQLITE_UPDATE)
return FORGET_UPDATES[p1 ?? ""]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_INSERT || action === C2.SQLITE_DELETE)
return FORGET_WRITES[action]?.has(p1 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_PRAGMA)
return readsDataVersion(p1, p2) || p1 === "secure_delete" && ["on", "1", "true"].includes((p2 ?? "").toLowerCase()) || p1 === "wal_checkpoint" ? C2.SQLITE_OK : C2.SQLITE_DENY;
if (action === C2.SQLITE_READ || action === C2.SQLITE_SELECT || action === C2.SQLITE_FUNCTION || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
return C2.SQLITE_OK;
return C2.SQLITE_DENY;
}
function checkedWrites(raw) {
let checked = false;
raw.prepare = (text3, ...rest) => {
const st = DatabaseSync2.prototype.prepare.call(raw, text3, ...rest);
if (text3 !== "begin immediate")
return st;
const begin = () => {
st.run();
try {
requireRevision(raw);
} catch (e) {
try {
raw.prepare("rollback").run();
} catch {}
throw e;
}
checked = true;
};
return {
columns: () => st.columns(),
run: () => {
begin();
return { changes: 0, lastInsertRowid: 0 };
},
all: () => {
begin();
return [];
},
get: () => {
begin();
return;
},
iterate: () => {
throw new Error("begin immediate runs through run, all, or get");
}
};
};
return (action, p1, p2) => {
if (action === C2.SQLITE_PRAGMA && p1 === "user_version" && p2 === null)
return C2.SQLITE_OK;
if (action === C2.SQLITE_TRANSACTION && p1 === "BEGIN")
checked = false;
if (action === C2.SQLITE_SAVEPOINT && !raw.isTransaction)
checked = false;
if (writes(action) && !SHADOW.test(p1 ?? "")) {
if (!raw.isTransaction)
checked = false;
if (!checked)
return C2.SQLITE_DENY;
}
return null;
};
}
function connectWriter(role, file = dbFile(), create = false, busyMs) {
requireRuntime();
if (!create)
requireFile(file);
const raw = new DatabaseSync2(file);
try {
prepare(raw, create ? "none" : role === "ingest" || role === "forget" ? "revision" : "generation", busyMs);
raw.function("sphica_terms", { deterministic: true }, (text3) => terms(String(text3 ?? "")).join(" "));
} catch (e) {
raw.close();
throw e;
}
if (role === "ingest" || role === "forget") {
const gate = checkedWrites(raw);
raw.setAuthorizer((action, p1, p2, _db, trigger) => gate(action, p1, p2) ?? (role === "ingest" ? ingestAuthorizer(action, p1, p2, trigger) : forgetAuthorizer(action, p1, p2)));
} else if (role === "capture") {
let own = false;
raw.setAuthorizer((action, p1, p2, _db, triggerOrView) => captureAuthorizer(own, action, p1, p2, triggerOrView));
const prepare2 = raw.prepare.bind(raw);
const exec = raw.exec.bind(raw);
const mark2 = (f) => (...a) => {
own = true;
try {
return f(...a);
} finally {
own = false;
}
};
raw.prepare = mark2(prepare2);
raw.exec = mark2(exec);
}
return raw;
}
function openWriter(role, file = dbFile(), busyMs) {
return kyselyOn(() => connectWriter(role, file, false, busyMs));
}
// server/src/knowledge.ts
var sessionId = (projectId, host, externalId) => uuidFrom(String(projectId), host, externalId);
// server/src/once.ts
import fs5 from "node:fs";
import os3 from "node:os";
import path5 from "node:path";
function markOnce(kind, key) {
const user = (() => {
try {
return os3.userInfo().username;
} catch {
return String(process.getuid?.() ?? "user");
}
})();
const dir = path5.join(os3.tmpdir(), `sphica-${sha256(user).toString("hex").slice(0, 12)}`, kind);
try {
fs5.mkdirSync(dir, { recursive: true, mode: 448 });
fs5.writeFileSync(path5.join(dir, sha256(key).toString("hex").slice(0, 24)), "", { flag: "wx" });
return true;
} catch (e) {
return e.code !== "EEXIST";
}
}
// server/src/project.ts
import fs6 from "node:fs";
import path7 from "node:path";
// server/src/anchors.ts
import path6 from "node:path";
var MAX_BYTES = 2 * 1024 * 1024;
var leaves = (rel) => rel === ".." || rel.startsWith(`..${path6.sep}`) || path6.isAbsolute(rel);
// server/src/project.ts
var localFile = () => path7.join(sphicaHome(), "projects.json");
var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
function legacyRemote(url) {
const raw = String(url ?? "").trim();
if (!raw)
return null;
const scp = raw.match(/^(?:[^@/]+@)?([^:/]+):(?!\/)(.+?)(?:\.git)?$/);
if (scp)
return `${scp[1]}/${scp[2]}`;
try {
const u = new URL(raw);
if (!u.hostname)
return null;
const p = u.pathname.replace(/\.git$/, "").replace(/^\/+|\/+$/g, "");
return p ? `${u.hostname}/${p}` : u.hostname;
} catch {
return null;
}
}
var fold = (s) => s.replace(/[A-Z]+/g, (m) => m.toLowerCase());
function normalizeKey(key) {
if (!key.startsWith("git:"))
return key;
const rest = key.slice(4);
const cut = rest.indexOf("/");
const host = fold(cut < 0 ? rest : rest.slice(0, cut));
return host === "github.com" ? fold(key) : `git:${host}${cut < 0 ? "" : rest.slice(cut)}`;
}
var ask = (fn) => {
try {
return fn() || null;
} catch {
return null;
}
};
var top = (dir) => ask(() => topLevel(dir, { timeout: 5000 }));
function localMap() {
let raw;
try {
raw = fs6.readFileSync(localFile(), "utf8");
} catch (e) {
if (e.code === "ENOENT")
return {};
throw e;
}
let m;
try {
m = JSON.parse(raw);
} catch {
m = null;
}
if (!m || typeof m !== "object" || Array.isArray(m) || Object.entries(m).some(([root, name]) => !path7.isAbsolute(root) || typeof name !== "string" || !LOCAL_KEY.test(name)))
throw new Error(`${localFile()} is not a valid JSON project table. Fix or delete it, then name the project again.`);
return m;
}
function identify(dir) {
const given = path7.resolve(dir);
const found = top(given);
const root = found || given;
const legacy = found ? legacyRemote(ask(() => originUrl(root, { timeout: 5000 }))) : null;
if (legacy) {
const key = normalizeKey(`git:${legacy}`);
const remote = key.slice(4);
return { key, legacyKey: `git:${legacy}`, root, name: remote.split("/").slice(1).join("/") || remote };
}
const map = localMap();
for (let d = root;; d = path7.dirname(d)) {
const local = map[d];
if (local && LOCAL_KEY.test(local))
return { key: `local:${local}`, legacyKey: `local:${local}`, root: d, name: local };
if (found || path7.dirname(d) === d)
return null;
}
}
function relativeTo(root, file, cwd = root) {
const abs = path7.resolve(cwd, file);
const rel = path7.relative(root, abs);
if (!rel || leaves(rel) || /\p{Cc}/u.test(rel))
return null;
return rel.split(path7.sep).join("/");
}
function patchPaths(patch) {
const out = [];
for (const line of patch.split(`
`)) {
const m = line.match(/^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)$/);
if (m?.[1])
out.push(m[1].trim());
}
return out;
}
// server/src/worktree.ts
import fs7 from "node:fs";
import path8 from "node:path";
var MAX_PATHS = 200;
var LIMITS = { timeout: 5000, max: 16 * 1024 * 1024 };
var STATUS_DEADLINE = 5000;
var usable = (p) => p !== "" && !p.includes("\\") && !/\p{Cc}/u.test(p);
async function snapshot(root) {
const until = Date.now() + STATUS_DEADLINE;
const out = await worktreeStatus(root, STATUS_DEADLINE);
if (out === null)
return null;
const fields = out.split("\x00");
const entries = {};
for (let i = 0;i < fields.length; i++) {
const f = fields[i] ?? "";
const skip = { "1": 8, "2": 9, u: 10, "?": 1 }[f[0] ?? ""];
if (!skip)
continue;
const parts = f.split(" ");
const p = parts.slice(skip).join(" ");
if (f[0] === "2")
i++;
if (!usable(p))
continue;
let st;
try {
st = fs7.lstatSync(path8.join(root, p), { throwIfNoEntry: false });
} catch {
st = undefined;
}
entries[p] = `${parts.slice(0, skip).join(" ")} ${st ? `${st.size}:${st.mtimeMs}` : "gone"}`;
}
let head2 = null;
try {
const left = until - Date.now();
if (left > 0)
head2 = commitOf(root, "HEAD", { ...LIMITS, timeout: left }) || null;
} catch {}
return { head: head2, entries };
}
function changed(root, before, after) {
const paths = new Set;
for (const p of new Set([...Object.keys(before.entries), ...Object.keys(after.entries)]))
if (before.entries[p] !== after.entries[p])
paths.add(p);
if (before.head && after.head && before.head !== after.head && isAncestor(root, before.head, after.head, LIMITS)) {
let between = [];
try {
between = commitDiffNames(root, before.head, after.head, LIMITS);
} catch {}
for (const p of between)
if (usable(p))
paths.add(p);
}
return [...paths].sort().slice(0, MAX_PATHS);
}
// server/src/capture.ts
var spoolDir = () => path9.join(sphicaHome(), "spool");
var stateFile = () => path9.join(sphicaHome(), "capture.json");
var rejectedDir = () => path9.join(spoolDir(), "rejected");
var unregisteredDir = () => path9.join(spoolDir(), "unregistered");
var callsDir = () => path9.join(spoolDir(), "calls");
var callsRejectedDir = () => path9.join(callsDir(), "rejected");
var HOLD_DAYS = 30;
var HOLD_MAX = 1000;
var baselineDir = () => path9.join(sphicaHome(), "worktree");
function current(raw) {
const r = raw;
if (typeof r.project !== "string")
throw new Error("queue record without a project key");
if (r.v === 2)
return raw;
if (r.v !== 1)
throw new Error(`unknown queue record version ${String(r.v)}`);
const old = raw;
if (old.kind === "message")
return {
...old,
v: 2,
kind: "message",
speaker: old.speaker === "self" ? "owner" : "assistant",
redacted: false
};
if (old.action !== "edit")
return null;
return { ...old, v: 2, kind: "edit", event: null, path: old.path, via: "tool" };
}
var MAX_MESSAGE = 128 * 1024;
var KEEP = 8 * 1024;
function fit(body) {
const all = bytes(body);
if (all <= MAX_MESSAGE) {
const kept = mask(body);
return { body: kept, truncated: false, redacted: kept !== body, originalBytes: all };
}
const start = head(body, KEEP * 2);
const end = tail(body, KEEP * 2);
const a = head(mask(start), KEEP);
const z = tail(mask(end), KEEP);
const cut = all - bytes(a) - bytes(z);
return {
body: `${a}
[${cut.toLocaleString("en-US")} bytes in the middle not saved]
${z}`,
truncated: true,
redacted: a !== head(start, KEEP) || z !== tail(end, KEEP),
originalBytes: all
};
}
function prune(held, removed = () => {}) {
let files;
try {
files = fs8.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
} catch {
return;
}
const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
const stale = files.filter((f) => Number(f.split("-")[0]) < cutoff);
const over = files.slice(0, Math.max(0, files.length - HOLD_MAX));
for (const f of new Set([...stale, ...over])) {
fs8.rmSync(path9.join(held, f), { force: true });
removed();
}
}
function put(dir, record) {
fs8.mkdirSync(dir, { recursive: true, mode: 448 });
const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
const tmp = path9.join(dir, `.${name}`);
fs8.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
fs8.renameSync(tmp, path9.join(dir, name));
return path9.join(dir, name);
}
function spool(record) {
put(spoolDir(), record);
}
var branchOf = (root) => {
try {
const dotgit = path9.join(root, ".git");
const gitdir = fs8.statSync(dotgit).isFile() ? path9.resolve(root, fs8.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
const h = fs8.readFileSync(path9.join(gitdir, "HEAD"), "utf8").trim();
return h.startsWith("ref: refs/heads/") ? h.slice("ref: refs/heads/".length) : null;
} catch {
return null;
}
};
function isOwnerTurn(input, parent = process.env.SPHICA_PARENT_SESSION, entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT, codexParent) {
if (!input.session_id || input.agent_id)
return false;
if (codexParent && codexParent !== input.session_id)
return false;
if (entrypoint?.startsWith("sdk-"))
return false;
if (parent)
return parent === input.session_id;
return true;
}
var INJECTED = [
/^<(?:task-notification|channel|cross-session-message|teammate-message|agent-message|slack-ping|slack-tag-message|fetched-web-content|remote-review|remote-review-progress)[\s>]/,
/^(?:\d+ background agents were stopped by the user:|Background agent ".*" was stopped by the user\.)/,
/^(?:Another Claude|A peer) session sent a message(?: while you were working)?:/
];
var digest = (s) => sha256(s).toString("hex").slice(0, 16);
function answersOf(input) {
const response = input.tool_response;
const answers = response?.answers;
if (!answers || typeof answers !== "object")
return null;
const pairs = Object.entries(answers);
if (!pairs.length)
return null;
return {
questions: pairs.map(([q], i) => `Q${i + 1}: ${q}`).join(`
`),
answers: pairs.map(([q, a], i) => {
const notes = response?.annotations?.[q]?.notes;
const memo = typeof notes === "string" && notes.trim() ? `
Notes: ${notes.trim()}` : "";
return `A${i + 1}: ${Array.isArray(a) ? a.join(" / ") : String(a)}${memo}`;
}).join(`
`)
};
}
function captureNotice(file = dbFile()) {
if (!fs8.existsSync(file))
return panel("sphica: no database, so conversations are not recorded", [file], "Create it with sphica init");
const s = readState();
if (s.unreadable)
return panel("sphica: cannot read the recording queue", [spoolDir(), s.unreadable], "Check with sphica doctor");
if (s.stuck)
return panel("sphica: cannot send recordings", [`${s.pending} pending / failed: ${plain2(s.stuck.slice(0, 120))}`], "Check with sphica doctor");
if (s.rejected)
return panel(`sphica: the database rejected ${plural(s.rejected, "record")}`, [rejectedDir(), `Move them back to ${spoolDir()} to resend`], "Fix them first, then check with sphica doctor");
return null;
}
var turnDir = (host, session) => path9.join(baselineDir(), digest(`${host}\x00${session}`));
var startFile = (dir, turn) => path9.join(dir, `${digest(turn)}.json`);
var isStart = (v) => {
const s = v;
return !!s && typeof s === "object" && typeof s.turn === "string" && typeof s.running === "boolean" && (s.seq === null || Number.isSafeInteger(s.seq)) && (s.entries === null || typeof s.entries === "object" && !Array.isArray(s.entries)) && (s.head === null || typeof s.head === "string");
};
function readStart(file) {
try {
const s = JSON.parse(fs8.readFileSync(file, "utf8"));
return isStart(s) ? s : null;
} catch {
return null;
}
}
function readStarts(dir) {
let names;
try {
names = fs8.readdirSync(dir);
} catch (e) {
return e.code === "ENOENT" ? [] : null;
}
const starts = [];
for (const name of names) {
if (name.startsWith("."))
continue;
const s = readStart(path9.join(dir, name));
if (!s)
return null;
starts.push(s);
}
return starts;
}
function newestTurn(starts) {
if (!starts?.length || starts.some((s) => s.seq === null))
return null;
const top2 = Math.max(...starts.map((s) => s.seq));
const at = starts.filter((s) => s.seq === top2);
return at.length === 1 ? at[0]?.turn ?? null : null;
}
function writeStart(dir, s, file = startFile(dir, s.turn)) {
fs8.mkdirSync(dir, { recursive: true, mode: 448 });
const tmp = path9.join(dir, `.${path9.basename(file)}.${process.pid}.tmp`);
fs8.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
fs8.renameSync(tmp, file);
}
async function openTurn(dir, turn, root) {
if (readStart(startFile(dir, turn))?.running)
return null;
const starts = readStarts(dir);
const seq = starts && !starts.some((s) => s.seq === null) ? Math.max(0, ...starts.map((s) => s.seq)) + 1 : null;
const now = await snapshot(root);
return () => writeStart(dir, { head: now?.head ?? null, entries: now?.entries ?? null, running: true, turn, seq });
}
async function closeTurn(dir, turn, root) {
const own = readStart(startFile(dir, turn));
if (!own?.entries)
return null;
const before = { head: own.head, entries: own.entries };
const now = await snapshot(root);
return () => {
if (newestTurn(readStarts(dir)) !== turn || JSON.stringify(readStart(startFile(dir, turn))) !== JSON.stringify(own))
return [];
writeStart(dir, { ...own, ...now ?? {}, running: false });
return now ? changed(root, before, now) : [];
};
}
function stopTurn(dir, turn) {
const own = readStart(startFile(dir, turn));
if (own?.entries || own?.running)
writeStart(dir, { ...own, head: null, entries: null, running: false });
}
function pruneBaselines() {
const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
const fresh = (file) => (fs8.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
let names;
try {
names = fs8.readdirSync(baselineDir());
} catch {
return;
}
for (const name of names) {
const at = path9.join(baselineDir(), name);
if (!fs8.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
if (!fresh(at))
fs8.rmSync(at, { force: true });
} else {
const files = fs8.readdirSync(at);
if (files.length && !files.some((f) => fresh(path9.join(at, f))))
fs8.rmSync(at, { recursive: true, force: true });
}
}
}
function attempt(fn) {
try {
return fn();
} catch {
return;
}
}
async function attemptAsync(fn) {
try {
return await fn();
} catch {
return;
}
}
function whoseTurn(host, input) {
if (!isOwnerTurn(input, undefined, undefined, host === "codex" ? process.env.CODEX_THREAD_ID : undefined))
return "other";
if (host !== "codex")
return "owner";
const thread = codexThread(input);
if (ownThread(input, thread))
return "owner";
return childThread(input, thread) === null ? "unconfirmed" : "other";
}
var unconfirmed = (input) => !markOnce("unconfirmed", `codex\x00${input.session_id}`) ? null : typeof input.transcript_path === "string" ? panel("sphica: this Codex session is not recorded", ["Its session log does not show that these messages are yours"], "Update Sphica and Codex; if it stays, report it") : panel("sphica: this Codex session is not recorded", [
"Codex named no session log (as with --ephemeral), so Sphica cannot confirm these messages are yours"
], "To record a session, start Codex without --ephemeral");
async function onHook(host, input) {
const event = input.hook_event_name;
const whose = whoseTurn(host, input);
if (whose !== "owner")
return {
flush: false,
notice: whose === "unconfirmed" && event === "UserPromptSubmit" ? unconfirmed(input) : null
};
if (event === "SessionStart") {
const file = process.env.CLAUDE_ENV_FILE;
if (file && input.session_id && /^[A-Za-z0-9_-]+$/.test(input.session_id)) {
fs8.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
`);
}
attempt(pruneBaselines);
return { flush: false, notice: captureNotice() };
}
if (event === "Interrupt") {
const turn2 = input.prompt_id ?? input.turn_id;
if (turn2)
attempt(() => stopTurn(turnDir(host, String(input.session_id)), turn2));
return { flush: true };
}
const place = identify(input.cwd ?? process.cwd());
if (!place)
return { flush: false };
const turn = input.prompt_id ?? input.turn_id;
if (!turn)
return { flush: false };
const at = new Date().toISOString();
const base = {
v: 2,
host,
session: String(input.session_id),
project: place.legacyKey,
branch: branchOf(place.root),
turn,
at
};
const say = (key, speaker, raw, when = at) => {
const kept = fit(clean(raw).trim());
if (!kept.body.trim())
return;
const id = `${key}:${digest(kept.body)}`;
spool({ ...base, at: when, kind: "message", id, speaker, ...kept });
};
const dir = turnDir(host, base.session);
if (event === "UserPromptSubmit" && input.prompt) {
const prompt = input.prompt.trimStart();
if (!INJECTED.some((r) => r.test(prompt)))
say(`${turn}:owner`, "owner", prompt);
}
if (event === "UserPromptSubmit")
await attemptAsync(async () => (await openTurn(dir, turn, place.root))?.());
if (event === "Stop") {
if (input.last_assistant_message)
say(`${turn}:assistant`, "assistant", input.last_assistant_message);
const paths = await attemptAsync(async () => {
const finish = await closeTurn(dir, turn, place.root);
if (finish)
return finish();
stopTurn(dir, turn);
return [];
});
for (const p of paths ?? [])
spool({ ...base, kind: "edit", event: null, path: p, via: "status" });
return { flush: true };
}
if (event === "PostToolUse") {
const tool = input.tool_name ?? "";
const ti = input.tool_input ?? {};
if (tool === "AskUserQuestion") {
const said = answersOf(input);
if (said) {
const id = `${turn}:ask:${input.tool_use_id ?? at}`;
say(`${id}:q`, "assistant", said.questions, new Date(Date.parse(at) - 1).toISOString());
say(id, "owner", said.answers);
}
return { flush: false };
}
if (tool === "Read")
return { flush: false };
const cwd = input.cwd ?? place.root;
const files = (tool === "apply_patch" ? patchPaths(String(ti.command ?? "")) : [ti.file_path, ti.notebook_path].filter((p) => typeof p === "string")).flatMap((p) => relativeTo(place.root, p, cwd) ?? []);
for (const p of files)
spool({ ...base, kind: "edit", event: input.tool_use_id ?? null, path: p, via: "tool" });
}
return { flush: false };
}
function readStateFile() {
let raw = {};
try {
const parsed = JSON.parse(fs8.readFileSync(stateFile(), "utf8"));
if (parsed && typeof parsed === "object")
raw = parsed;
} catch {}
const p = raw.pruned;
return {
flushedAt: typeof raw.flushedAt === "string" ? raw.flushedAt : undefined,
error: typeof raw.error === "string" ? raw.error || "unknown failure" : null,
deferred: typeof raw.deferred === "number" ? raw.deferred : undefined,
pruned: p && typeof p.at === "string" && typeof p.count === "number" ? { at: p.at, count: p.count } : undefined
};
}
function writeState(s) {
try {
fs8.writeFileSync(stateFile(), JSON.stringify({ ...s, pruned: s.pruned ?? readStateFile().pruned }));
} catch {}
}
function readState() {
const queue = listQueue(spoolDir());
const counts = {
pending: queue.files?.length ?? null,
rejected: listQueue(rejectedDir()).files?.length ?? null,
unregistered: listQueue(unregisteredDir()).files?.length ?? null
};
const state = readStateFile();
const stuck = state.error && (counts.pending ?? 0) > 0 ? state.error : null;
return { ...state, ...counts, unreadable: queue.code, stuck };
}
function listQueue(dir) {
try {
const names = fs8.readdirSync(dir);
return {
files: names.filter((f) => f.endsWith(".json") && !f.startsWith(".")),
temp: names.filter((f) => f.endsWith(".json") && f.startsWith(".")),
code: null
};
} catch (e) {
const code = e.code ?? "unknown";
return code === "ENOENT" ? { files: [], temp: [], code: null } : { files: null, temp: [], code };
}
}
var TEMP_AGE_MS = 60000;
var REASON = /^[a-z]+(-[a-z]+)?(:[A-Z]+)?$/;
function queueReport(now = Date.now()) {
const dirs = {
queue: spoolDir(),
calls: callsDir(),
rejected: rejectedDir(),
unregistered: unregisteredDir(),
callsRejected: callsRejectedDir()
};
const listed = Object.fromEntries(Object.entries(dirs).map(([k, d]) => [k, listQueue(d)]));
const report = (k) => {
const temp = { count: 0, oldestMs: 0, bytes: 0 };
for (const name of listed[k].temp)
try {
const st = fs8.statSync(path9.join(dirs[k], name));
const age = now - st.mtimeMs;
if (age < TEMP_AGE_MS)
continue;
temp.count++;
temp.bytes += st.size;
temp.oldestMs = Math.max(temp.oldestMs, age);
} catch {}
return { files: listed[k].files?.length ?? null, code: listed[k].code, temp };
};
const reasons = (k) => {
const out = {};
for (const name of listed[k].files ?? []) {
let why = "unknown";
try {
const text3 = fs8.readFileSync(path9.join(dirs[k], `${name}.reason`), "utf8");
if (REASON.test(text3))
why = text3;
} catch {}
out[why] = (out[why] ?? 0) + 1;
}
return out;
};
const read = (dir, name) => {
try {
return JSON.parse(fs8.readFileSync(path9.join(dir, name), "utf8"));
} catch {
return null;
}
};
const held = new Map;
for (const name of listed.unregistered.files ?? []) {
const key = read(dirs.unregistered, name)?.project;
const project = typeof key === "string" ? key : "unreadable";
const age = Math.max(0, now - (Number(name.split("-")[0]) || now));
const h = held.get(project) ?? { count: 0, oldestMs: 0 };
held.set(project, { count: h.count + 1, oldestMs: Math.max(h.oldestMs, age) });
}
const waiting = new Set;
for (const name of listed.calls.files ?? []) {
const o = observation(read(dirs.calls, name));
if (o)
waiting.add(o.toolUse);
}
return {
dirs: Object.fromEntries(Object.keys(dirs).map((k) => [k, report(k)])),
rejected: reasons("rejected"),
callsRejected: reasons("callsRejected"),
held: [...held].map(([project, h]) => ({ project, ...h })).sort((a, b) => a.project.localeCompare(b.project)),
waiting,
pruned: readStateFile().pruned
};
}
function lock() {
const file = path9.join(spoolDir(), ".lock");
fs8.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
for (let attempt2 = 0;attempt2 < 2; attempt2++) {
try {
fs8.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
return () => {
try {
if (fs8.readFileSync(file, "utf8") === String(process.pid))
fs8.rmSync(file, { force: true });
} catch {}
};
} catch (e) {
if (e.code !== "EEXIST")
throw e;
}
const st = fs8.statSync(file, { throwIfNoEntry: false });
if (!st)
continue;
const holder = Number(fs8.readFileSync(file, "utf8") || 0);
const fresh = Date.now() - st.mtimeMs < 5 * 60000;
const alive = (() => {
if (holder <= 0)
return fresh;
try {
return process.kill(holder, 0);
} catch {
return false;
}
})();
if (alive && fresh)
return null;
fs8.rmSync(file, { force: true });
}
return null;
}
var BATCH = 500;
var FLUSH_BUDGET_MS = 30000;
var TOOL_FLUSH_BUDGET_MS = 2000;
var ROWS = 1000;
var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
async function projectsOf(trx, keys) {
if (!keys.length)
return new Map;
const all = await trx.selectFrom("project").select(["id", "key"]).execute();
const exact = new Map(all.map((p) => [p.key, p.id]));
const normal = Map.groupBy(all, (p) => normalizeKey(p.key));
const found = new Map;
for (const k of keys) {
const same = normal.get(normalizeKey(k));
const id = exact.get(k) ?? (same?.length === 1 ? same[0]?.id : undefined);
if (id !== undefined)
found.set(k, id);
}
return found;
}
async function write(db, batch) {
return inTransaction(db, async (trx) => {
const projects = await projectsOf(trx, batch.map((r) => r.project));
const sessions = new Map;
for (const r of batch) {
const p = projects.get(r.project);
if (p === undefined)
continue;
const id = sessionId(p, r.host, r.session);
const prev = sessions.get(id);
if (!prev || Date.parse(r.at) < Date.parse(prev.at))
sessions.set(id, { project: p, host: r.host, session: r.session, branch: r.branch, at: r.at });
}
for (const part of chunks([...sessions]))
await trx.insertInto("capture_session").values(part.map(([id, v]) => ({
id,
project_id: v.project,
host: v.host,
external_id: v.session,
branch: v.branch,
started_at: iso(v.at)
}))).execute();
const messages = batch.flatMap((m) => {
const p = m.kind === "message" ? projects.get(m.project) : undefined;
if (m.kind !== "message" || p === undefined)
return [];
return [{ m, session: sessionId(p, m.host, m.session) }];
});
const present = async () => {
let n = 0;
for (const part of chunks(messages))
for (const [session, ids] of Map.groupBy(part, (x) => x.session))
n += (await trx.selectFrom("source").select("id").where("kind", "=", "session_message").where("session_id", "=", session).where("external_id", "in", ids.map((x) => x.m.id)).execute()).length;
return n;
};
const before = await present();
const now = iso(Date.now());
for (const part of chunks(messages))
await trx.insertInto("capture_message").values(part.map((x) => ({
external_id: x.m.id,
session_id: x.session,
turn_id: x.m.turn,
speaker: x.m.speaker,
created_at: iso(x.m.at),
captured_at: now,
text: x.m.body,
truncated: x.m.truncated ? 1 : 0,
redacted: x.m.redacted ? 1 : 0,
original_bytes: x.m.originalBytes,
content_hash: sha256(x.m.body)
}))).execute();
const after = await present();
const edits = batch.flatMap((r) => {
const p = r.kind === "edit" ? projects.get(r.project) : undefined;
if (r.kind !== "edit" || p === undefined)
return [];
return [
{
session_id: sessionId(p, r.host, r.session),
turn_id: r.turn,
tool_event_id: r.event,
path: r.path,
via: r.via,
observed_at: iso(r.at)
}
];
});
for (const part of chunks(edits))
await trx.insertInto("capture_edit").values(part).execute();
return { sent: after - before, strayed: new Set(batch.filter((r) => !projects.has(r.project))) };
});
}
var REJECTED = new Set([18, 19, 20, 25]);
var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
var queued = (from) => {
try {
return fs8.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
} catch {
return [];
}
};
var CODE_NAMES = { 18: "TOOBIG", 19: "CONSTRAINT", 20: "MISMATCH", 25: "RANGE" };
function setAside(from, name, dir, reason2) {
fs8.mkdirSync(dir, { recursive: true, mode: 448 });
try {
fs8.renameSync(path9.join(from, name), path9.join(dir, name));
} catch (e) {
if (e.code === "ENOENT")
return;
throw e;
}
try {
fs8.writeFileSync(path9.join(dir, `${name}.reason`), reason2, { mode: 384 });
} catch {}
}
async function sendBatch(db, names) {
const held = unregisteredDir();
const records = [];
for (const { name, from } of names) {
let raw;
let r;
try {
raw = JSON.parse(fs8.readFileSync(path9.join(from, name), "utf8"));
} catch {
setAside(from, name, rejectedDir(), "unreadable");
continue;
}
try {
r = current(raw);
} catch {
setAside(from, name, rejectedDir(), typeof raw?.project === "string" ? "version" : "no-project");
continue;
}
if (r)
records.push({ name, from, r });
else
fs8.rmSync(path9.join(from, name), { force: true });
}
let sent = 0;
let strayed = [];
const bad = [];
try {
const out = await write(db, records.map((x) => x.r));
sent = out.sent;
strayed = records.filter((x) => out.strayed.has(x.r));
} catch (e) {
if (!rejected(e))
throw e;
for (const x of records) {
try {
const out = await write(db, [x.r]);
sent += out.sent;
if (out.strayed.size)
strayed.push(x);
} catch (e2) {
if (!rejected(e2))
throw e2;
bad.push({ ...x, why: `sqlite:${CODE_NAMES[sqliteCode(e2) ?? -1] ?? "unknown"}` });
}
}
}
for (const x of bad)
setAside(x.from, x.name, rejectedDir(), x.why);
if (strayed.length) {
fs8.mkdirSync(held, { recursive: true, mode: 448 });
for (const x of strayed) {
if (x.from === held)
continue;
try {
fs8.renameSync(path9.join(x.from, x.name), path9.join(held, x.name));
} catch (e) {
if (e.code !== "ENOENT")
throw e;
}
}
}
const moved = new Set([...bad, ...strayed].map((x) => x.name));
for (const x of records)
if (!moved.has(x.name))
fs8.rmSync(path9.join(x.from, x.name), { force: true });
return { sent, rejected: bad.length };
}
async function sendObservations(db, names) {
const aside = (name, why) => {
try {
setAside(callsDir(), name, callsRejectedDir(), why);
} catch {}
};
const rows = [];
for (const { name, from } of names) {
let text3;
try {
text3 = fs8.readFileSync(path9.join(from, name), "utf8");
} catch {
continue;
}
let o = null;
let why = "unreadable";
try {
o = observation(JSON.parse(text3));
why = "shape";
} catch {}
if (o)
rows.push({ name, o });
else
aside(name, why);
}
if (!rows.length)
return true;
const insert = (part) => db.insertInto("capture_tool_call").values(part.map((x) => observationRow(x.o))).execute();
const bad = new Map;
try {
await insert(rows);
} catch (e) {
if (!rejected(e))
return false;
for (const x of rows)
try {
await insert([x]);
} catch (e2) {
if (!rejected(e2))
return false;
bad.set(x.name, `sqlite:${CODE_NAMES[sqliteCode(e2) ?? -1] ?? "unknown"}`);
}
}
for (const x of rows) {
const why = bad.get(x.name);
if (why)
aside(x.name, why);
else
try {
fs8.rmSync(path9.join(callsDir(), x.name), { force: true });
} catch {}
}
return true;
}
async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
const deadline = Date.now() + budgetMs;
const dir = spoolDir();
const held = unregisteredDir();
const total = { sent: 0, deferred: 0, rejected: 0 };
let batches = 0;
let queueBatches = 0;
let removed = 0;
const pruned = () => removed ? { at: new Date().toISOString(), count: removed } : undefined;
for (let first = true;; first = false) {
let unlock = lock();
while (!unlock && Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
if (Date.now() < deadline)
unlock = lock();
}
if (!unlock)
return first ? { ...total, busy: true } : total;
let client = null;
const send = async (names) => {
client ??= openWriter("capture", file);
const r = await sendBatch(client, names);
total.sent += r.sent;
total.rejected += r.rejected;
batches++;
};
const late = () => batches > 0 && Date.now() >= deadline;
const sentBefore = batches;
try {
if (first) {
prune(held, () => removed++);
for (const part of chunks(queued(held), BATCH)) {
if (late())
break;
await send(part);
}
for (const part of chunks(queued(callsDir()), BATCH)) {
if (late())
break;
client ??= openWriter("capture", file);
if (!await sendObservations(client, part))
break;
batches++;
}
}
while (queueBatches === 0 || !late()) {
const part = queued(dir).slice(0, BATCH);
if (part.length === 0)
break;
await send(part);
queueBatches++;
}
prune(held, () => removed++);
total.deferred = queued(held).length;
if (batches > sentBefore)
writeState({
flushedAt: new Date().toISOString(),
error: null,
deferred: total.deferred,
pruned: pruned()
});
else if (removed)
writeState({ ...readStateFile(), pruned: pruned() });
} catch (e) {
writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300), pruned: pruned() });
throw e;
} finally {
await client?.destroy().catch(() => {});
unlock();
}
if (Date.now() >= deadline || queued(dir).length === 0)
return total;
}
}
async function readInput(stream) {
stream.setEncoding("utf8");
let raw = "";
for await (const chunk of stream)
raw += chunk;
return JSON.parse(raw || "{}");
}
var RECORD_TOOLS = "mcp__plugin_sphica_record__";
var OBSERVE_WAIT_MS = 5000;
var hostId = (v) => typeof v === "string" && /^[\x21-\x7e]{1,200}$/.test(v) ? v : null;
var OBSERVATION_KEYS = ["at", "host", "owner", "session", "tool", "toolUse", "turn", "v"].join();
function observation(raw) {
if (!raw || typeof raw !== "object" || Array.isArray(raw))
return null;
const o = raw;
if (Object.keys(o).sort().join() !== OBSERVATION_KEYS)
return null;
if (o.v !== 1 || o.host !== "claude-code" || !hostId(o.session) || !hostId(o.toolUse))
return null;
if (!hostId(o.tool)?.startsWith(RECORD_TOOLS))
return null;
if (o.turn !== null && !hostId(o.turn))
return null;
if (o.owner !== 0 && o.owner !== 1)
return null;
const at = typeof o.at === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(o.at) ? o.at : null;
if (!at || Number.isNaN(Date.parse(at)) || new Date(at).toISOString() !== at)
return null;
return o;
}
var observationRow = (o) => ({
host: o.host,
session_external: o.session,
turn_id: o.turn,
tool_use_id: o.toolUse,
tool_name: o.tool,
owner_turn: o.owner,
observed_at: o.at
});
async function observeRecordCall(file, input, owner, waitMs = OBSERVE_WAIT_MS) {
const o = observation({
v: 1,
host: "claude-code",
session: hostId(input.session_id),
turn: hostId(input.prompt_id),
toolUse: hostId(input.tool_use_id),
tool: hostId(input.tool_name),
owner: owner ? 1 : 0,
at: iso(Date.now())
});
if (!o)
return;
let kept = null;
try {
kept = put(callsDir(), o);
} catch {}
const cap = openWriter("capture", file, waitMs);
try {
await cap.insertInto("capture_tool_call").values(observationRow(o)).execute();
} finally {
await cap.destroy().catch(() => {});
}
if (kept)
try {
fs8.rmSync(kept, { force: true });
} catch {}
}
async function main() {
if (process.argv[2] === "--flush") {
await flush();
return;
}
const input = await readInput(process.stdin);
const host = process.argv[2] === "codex" ? "codex" : "claude-code";
if (host === "claude-code" && input.hook_event_name === "PreToolUse") {
await observeRecordCall(dbFile(), input, isOwnerTurn(input));
return;
}
if (host === "codex" && input.hook_event_name === "Stop")
process.stdout.write("{}");
const { flush: send, notice } = await onHook(host, input);
if (notice)
process.stdout.write(JSON.stringify({ systemMessage: notice }));
if (send)
spawn2(process.execPath, [process.argv[1] ?? "", "--flush"], {
detached: true,
stdio: "ignore",
windowsHide: true
}).unref();
}
if (process.argv[1] && /capture\.(ts|js)$/.test(process.argv[1])) {
main().catch(() => {});
}
export {
HOLD_DAYS,
HOLD_MAX,
MAX_MESSAGE,
TOOL_FLUSH_BUDGET_MS,
answersOf,
branchOf,
callsDir,
callsRejectedDir,
captureNotice,
closeTurn,
current,
fit,
flush,
isOwnerTurn,
observation,
observeRecordCall,
onHook,
openTurn,
queueReport,
readInput,
readState,
rejectedDir,
spoolDir,
turnDir,
unregisteredDir,
write
};