joist-core 2.3.0 → 2.4.0-next.10

package/build/queries/sql/expressions/types.d.mts

@@ -0,0 +1,114 @@
+import { ArrayAggExpressionOptions, ArrayAggInput, ParsedArrayAggExpression } from "./arrayAgg.mjs";
+import { CaseArmValue, CaseInput, CheckCase, ParsedCaseExpression } from "./case.mjs";
+import { CoalesceInput, ParsedCoalesceExpression } from "./coalesce.mjs";
+import { GreatestInput, ParsedGreatestExpression } from "./greatest.mjs";
+import { LeastInput, ParsedLeastExpression } from "./least.mjs";
+import { NullIfInput, ParsedNullIfExpression } from "./nullIf.mjs";
+import { CompatibleValue, MaybeNull, QueryJoinList } from "../query.mjs";
+import { BaseExpr, Expr, ExprBrand, ExprLike, exprBrand } from "../Expr.mjs";
+//#region src/queries/sql/expressions/types.d.ts
+/** Each operation owns its input fields; the combined input permits exactly one operation. */
+interface ExprInputs {
+  case: CaseInput;
+  arrayAgg: ArrayAggInput;
+  coalesce: CoalesceInput;
+  nullIf: NullIfInput;
+  greatest: GreatestInput;
+  least: LeastInput;
+}
+type ExprName = Exclude<keyof ExprInputs, "case" | "arrayAgg">;
+type ExprArgsInput = { [K in ExprName]: { readonly [P in K]: readonly unknown[]; }; }[ExprName];
+type ExprArgs<V> = Extract<V[keyof V & ExprName], readonly unknown[]>;
+/** An expression object used in select or passed to expr, i.e. { coalesce: [a.last_name, a.first_name] }. */
+type ExprInput = { [K in keyof ExprInputs]: ExprInputs[K] & { readonly [P in Exclude<keyof ExprInputs | "else", K>]?: never; }; }[keyof ExprInputs];
+declare const inputBrand: unique symbol;
+/** Retains the input object so query results can account for LEFT joins in each candidate separately. */
+type ExprFromInput<I> = Expr<InputResult<I, []>, ExpressionSources<I>> & {
+  readonly [inputBrand]: I;
+};
+/**
+ * Computes the SQL expression type, including null from LEFT joins.
+ * I.e. Book.title is string | null when Book is LEFT-joined; COALESCE(Book.title, "Unknown") is string.
+ */
+type ExpressionValue<V, J extends QueryJoinList> = unknown extends V ? V : V extends {
+  readonly [inputBrand]: infer I;
+} ? InputResult<I, J> : V extends {
+  readonly [exprBrand]: ExprBrand<infer R, infer S>;
+} ? MaybeNull<R, S, J> : V extends {
+  readonly arrayAgg: infer A;
+} ? ExpressionValue<ArrayAggValue<A>, J>[] | null : V extends ExprArgsInput ? V extends {
+  readonly nullIf: readonly unknown[];
+} ? ExpressionValue<ExprArgs<V>[0], J> | null : V extends {
+  readonly coalesce: readonly unknown[];
+} ? CoalesceValue<ExprArgs<V>, J> : Exclude<ExpressionValue<ExprArgs<V>[number], J>, null> | (null extends CoalesceValue<ExprArgs<V>, J> ? null : never) : V extends {
+  readonly case: infer A;
+} ? ExpressionValue<CaseArmValue<A>, J> | (A extends readonly [...unknown[], {
+  readonly else: unknown;
+}] ? never : null) : WidenLiteral<V>;
+/** Turns literal types such as "Alice" and 18 into string and number, including array elements. */
+type WidenLiteral<V> = V extends string ? string : V extends number ? number : V extends boolean ? boolean : V extends bigint ? bigint : V extends readonly (infer E)[] ? WidenLiteral<E>[] : V;
+/**
+ * Uses existing expressions' result types for their literal fallbacks, just as their codecs do at runtime.
+ * I.e. COALESCE(Book.id, "b:9") returns BookId rather than string. ExpressionValue supplies the nullability.
+ */
+type InputResult<I, J extends QueryJoinList> = [Exclude<BranchResult<I>, null>] extends [never] ? ExpressionValue<I, J> : Exclude<BranchResult<I>, null> | (null extends ExpressionValue<I, J> ? null : never);
+/** Collects the types supplied by columns and existing expressions, excluding plain literal fallbacks. */
+type BranchResult<V> = unknown extends V ? never : V extends ExprLike<infer R> ? R : V extends {
+  readonly arrayAgg: infer A;
+} ? BranchResult<ArrayAggValue<A>>[] : V extends ExprArgsInput ? BranchResult<V extends {
+  readonly nullIf: readonly unknown[];
+} ? ExprArgs<V>[0] : ExprArgs<V>[number]> : V extends {
+  readonly case: infer A;
+} ? BranchResult<CaseArmValue<A>> : never;
+/** A fixed non-null candidate guarantees a result; a possibly empty candidate array does not. */
+type CoalesceValue<A extends readonly unknown[], J extends QueryJoinList> = A extends readonly [infer H, ...infer T] ? Exclude<ExpressionValue<H, J>, null> | (null extends ExpressionValue<H, J> ? CoalesceValue<T, J> : never) : A extends readonly [...infer Before, infer Last] ? Exclude<ExpressionValue<A[number], J>, null> | (null extends ExpressionValue<Last, J> ? (null extends CoalesceValue<Before, J> ? null : never) : never) : ExpressionValue<A[number], J> | null;
+/** Conditions affect which value is chosen, but do not make that value nullable through a LEFT join. */
+type ExpressionSources<V> = unknown extends V ? string : V extends ExprLike<unknown> ? V[typeof exprBrand]["__source"] : V extends {
+  readonly arrayAgg: infer A;
+} ? ExpressionSources<ArrayAggValue<A>> : V extends ExprArgsInput ? ExpressionSources<ExprArgs<V>[number]> : V extends {
+  readonly case: infer A;
+} ? ExpressionSources<CaseArmValue<A>> : never;
+/**
+ * Compares every operand with the others using the same type check as query set operations.
+ * I.e. Author.age and 18 both yield number; Author.age and Author.first_name yield incompatible types.
+ * SQL storage types and codecs are checked separately at runtime.
+ */
+type CompatibleValues<V, All = V> = false extends (V extends unknown ? All extends unknown ? CompatibleValue<ExpressionValue<V, []>, ExpressionValue<All, []>> : never : never) ? "Expression values must have compatible types" : unknown;
+/** Checks nested expression shapes and literal fallbacks in one pass; R is the type supplied by existing expressions. */
+type CheckExpression<V, R> = V extends ExprLike<unknown> ? unknown : V extends {
+  readonly arrayAgg: infer A;
+} ? {
+  readonly arrayAgg: CheckArrayAgg<A, R extends readonly (infer E)[] ? E : never>;
+} & { readonly [K in Exclude<keyof V, "arrayAgg">]: never; } : V extends ExprArgsInput ? V extends ExprInput ? { readonly [K in keyof V]: K extends ExprName ? V[K] extends readonly unknown[] ? CheckOperands<V[K], K, R> : never : never; } : never : V extends {
+  readonly case: infer A;
+} ? {
+  readonly case: CheckCase<A, R>;
+} & CompatibleValues<CaseArmValue<A>> & { readonly [K in Exclude<keyof V, "case">]: never; } : V extends undefined ? "Use null for a SQL NULL value" : [R] extends [never] ? unknown : V extends null ? unknown : V extends (R extends readonly unknown[] ? Readonly<R> : R) ? unknown : "Literal values must match the expression";
+/** Checks fixed argument counts and then each operand; dynamic array lengths are checked at runtime. */
+type CheckOperands<A extends readonly unknown[], Name extends ExprName, R> = (Name extends "nullIf" ? number extends A["length"] ? unknown : A extends readonly [unknown, unknown] ? unknown : "NULLIF needs exactly two values" : A extends readonly [] ? `${Uppercase<Name>} needs at least one value` : unknown) & { readonly [K in keyof A]: CheckExpression<A[K], R>; } & CompatibleValues<A[number]>;
+/** Valid inputs need no extra constraint; this keeps spread arrays from losing their fixed final operand. */
+type CheckInput<I> = [I] extends [CheckExpression<I, Exclude<BranchResult<I>, null>>] ? unknown : CheckExpression<I, Exclude<BranchResult<I>, null>>;
+/**
+ * The internal form produced by parsing expression inputs, like ParsedFindQuery for em.find filters.
+ * Existing Expr instances remain intact; literal operands and CASE results are parsed recursively.
+ * CASE conditions retain their query input until SQL rendering supplies the alias context.
+ */
+type ParsedExpression = BaseExpr | ParsedLiteralExpression | ParsedArrayAggExpression | ParsedCoalesceExpression | ParsedNullIfExpression | ParsedGreatestExpression | ParsedLeastExpression | ParsedCaseExpression;
+/** A bound value whose encoder is selected from the surrounding expression. */
+interface ParsedLiteralExpression {
+  kind: "literal";
+  value: unknown;
+}
+/** The conversions shared by all result values, separate from their SQL rendering. */
+type ResultCodec = Pick<BaseExpr, "outputType" | "encode" | "decode">;
+/** Extracts the aggregate value from compact or expanded ARRAY_AGG input. */
+type ArrayAggValue<A> = A extends {
+  readonly value: infer V;
+} ? V : A;
+/** Checks the aggregate value and rejects unknown expanded option keys. */
+type CheckArrayAgg<A, R> = A extends {
+  readonly value: unknown;
+} ? A extends ArrayAggExpressionOptions ? { readonly [K in keyof A]: K extends "value" ? CheckExpression<A[K], R> : K extends keyof ArrayAggExpressionOptions ? A[K] : never; } : never : CheckExpression<A, R>;
+//#endregion
+export { CheckExpression, CheckInput, ExprFromInput, ExprInput, ExprName, ExpressionSources, ExpressionValue, ParsedExpression, ParsedLiteralExpression, ResultCodec };
+//# sourceMappingURL=types.d.mts.map

package/build/queries/sql/expressions/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/types.ts"],"mappings":"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"}

package/build/queries/sql/expressions/types.js

@@ -0,0 +1 @@
+export {};

package/build/queries/sql/keywords.cjs

@@ -0,0 +1,136 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/queries/sql/keywords.ts
+const escapeMapped = new Map([
+	"all",
+	"alter",
+	"analyse",
+	"analyze",
+	"and",
+	"any",
+	"array",
+	"as",
+	"asc",
+	"avg",
+	"between",
+	"by",
+	"asymmetric",
+	"both",
+	"case",
+	"count",
+	"cast",
+	"check",
+	"collate",
+	"column",
+	"constraint",
+	"create",
+	"delete",
+	"current_catalog",
+	"current_date",
+	"current_role",
+	"current_time",
+	"current_timestamp",
+	"current_user",
+	"default",
+	"deferrable",
+	"desc",
+	"distinct",
+	"drop",
+	"do",
+	"else",
+	"end",
+	"from",
+	"except",
+	"false",
+	"fetch",
+	"for",
+	"foreign",
+	"from",
+	"grant",
+	"group",
+	"having",
+	"in",
+	"inner",
+	"insert",
+	"initially",
+	"intersect",
+	"into",
+	"is",
+	"join",
+	"left",
+	"like",
+	"max",
+	"min",
+	"lateral",
+	"leading",
+	"limit",
+	"localtime",
+	"localtimestamp",
+	"not",
+	"null",
+	"offset",
+	"on",
+	"only",
+	"or",
+	"order",
+	"outer",
+	"right",
+	"placing",
+	"primary",
+	"references",
+	"returning",
+	"select",
+	"set",
+	"sum",
+	"session_user",
+	"some",
+	"symmetric",
+	"table",
+	"then",
+	"to",
+	"trailing",
+	"true",
+	"union",
+	"update",
+	"values",
+	"unique",
+	"user",
+	"using",
+	"variadic",
+	"when",
+	"where",
+	"window",
+	"with"
+].map((k) => [k, `"${k}"`]));
+const allLower = /^[a-z0-9_]+$/;
+/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */
+function kq(ident) {
+	if (!allLower.test(ident)) return `"${ident}"`;
+	return escapeMapped.get(ident) ?? ident;
+}
+/**
+* Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or
+* `a.column` column.
+*
+* `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;
+* these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which
+* keeps display-name keys (`select: { "Book Count": ... }`) working. Names longer than PG's 63-byte
+* identifier limit are still rejected: PG would silently truncate them and break row decoding.
+*/
+function safeKq(ident) {
+	if (ident.length > 63) throw new Error(`Identifier '${ident}' is longer than PG's 63-byte limit`);
+	if (!ident.includes("\"")) return kq(ident);
+	return `"${ident.replaceAll("\"", "\"\"")}"`;
+}
+function kqDot(alias, column) {
+	return `${kq(alias)}.${kq(column)}`;
+}
+function kqStar(alias) {
+	return `${kq(alias)}.*`;
+}
+//#endregion
+exports.kq = kq;
+exports.kqDot = kqDot;
+exports.kqStar = kqStar;
+exports.safeKq = safeKq;
+
+//# sourceMappingURL=keywords.cjs.map

package/build/queries/sql/keywords.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.cjs","names":[],"sources":["../../../src/queries/sql/keywords.ts"],"sourcesContent":["// select word from pg_get_keywords() where catdesc = 'reserved' order by word;\nconst keywords = [\n  \"all\",\n  \"alter\",\n  \"analyse\",\n  \"analyze\",\n  \"and\",\n  \"any\",\n  \"array\",\n  \"as\",\n  \"asc\",\n  \"avg\",\n  \"between\",\n  \"by\",\n  \"asymmetric\",\n  \"both\",\n  \"case\",\n  \"count\",\n  \"cast\",\n  \"check\",\n  \"collate\",\n  \"column\",\n  \"constraint\",\n  \"create\",\n  \"delete\",\n  \"current_catalog\",\n  \"current_date\",\n  \"current_role\",\n  \"current_time\",\n  \"current_timestamp\",\n  \"current_user\",\n  \"default\",\n  \"deferrable\",\n  \"desc\",\n  \"distinct\",\n  \"drop\",\n  \"do\",\n  \"else\",\n  \"end\",\n  \"from\",\n  \"except\",\n  \"false\",\n  \"fetch\",\n  \"for\",\n  \"foreign\",\n  \"from\",\n  \"grant\",\n  \"group\",\n  \"having\",\n  \"in\",\n  \"inner\",\n  \"insert\",\n  \"initially\",\n  \"intersect\",\n  \"into\",\n  \"is\",\n  \"join\",\n  \"left\",\n  \"like\",\n  \"max\",\n  \"min\",\n  \"lateral\",\n  \"leading\",\n  \"limit\",\n  \"localtime\",\n  \"localtimestamp\",\n  \"not\",\n  \"null\",\n  \"offset\",\n  \"on\",\n  \"only\",\n  \"or\",\n  \"order\",\n  \"outer\",\n  \"right\",\n  \"placing\",\n  \"primary\",\n  \"references\",\n  \"returning\",\n  \"select\",\n  \"set\",\n  \"sum\",\n  \"session_user\",\n  \"some\",\n  \"symmetric\",\n  \"table\",\n  \"then\",\n  \"to\",\n  \"trailing\",\n  \"true\",\n  \"union\",\n  \"update\",\n  \"values\",\n  \"unique\",\n  \"user\",\n  \"using\",\n  \"variadic\",\n  \"when\",\n  \"where\",\n  \"window\",\n  \"with\",\n];\n\n// Cache all keywords => their escaped equivalent\nconst escapeMapped = new Map(keywords.map((k) => [k, `\"${k}\"`]));\nconst allLower = /^[a-z0-9_]+$/;\n\n/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */\nexport function kq(ident: string): string {\n  // All camel-cased identifiers/column names need to be quoted\n  if (!allLower.test(ident)) return `\"${ident}\"`;\n  return escapeMapped.get(ident) ?? ident;\n}\n\n/**\n * Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or\n * `a.column` column.\n *\n * `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;\n * these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which\n * keeps display-name keys (`select: { \"Book Count\": ... }`) working. Names longer than PG's 63-byte\n * identifier limit are still rejected: PG would silently truncate them and break row decoding.\n */\nexport function safeKq(ident: string): string {\n  if (ident.length > 63) throw new Error(`Identifier '${ident}' is longer than PG's 63-byte limit`);\n  if (!ident.includes('\"')) return kq(ident);\n  return `\"${ident.replaceAll('\"', '\"\"')}\"`;\n}\n\nexport function kqDot(alias: string, column: string): string {\n  return `${kq(alias)}.${kq(column)}`;\n}\n\nexport function kqStar(alias: string): string {\n  return `${kq(alias)}.*`;\n}\n"],"mappings":";;AAwGA,MAAM,eAAe,IAAI,IAAI;CAtG3B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAIkC,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC;AAC/D,MAAM,WAAW;;AAGjB,SAAgB,GAAG,OAAuB;CAExC,IAAI,CAAC,SAAS,KAAK,KAAK,GAAG,OAAO,IAAI,MAAM;CAC5C,OAAO,aAAa,IAAI,KAAK,KAAK;AACpC;;;;;;;;;;AAWA,SAAgB,OAAO,OAAuB;CAC5C,IAAI,MAAM,SAAS,IAAI,MAAM,IAAI,MAAM,eAAe,MAAM,oCAAoC;CAChG,IAAI,CAAC,MAAM,SAAS,IAAG,GAAG,OAAO,GAAG,KAAK;CACzC,OAAO,IAAI,MAAM,WAAW,MAAK,MAAI,EAAE;AACzC;AAEA,SAAgB,MAAM,OAAe,QAAwB;CAC3D,OAAO,GAAG,GAAG,KAAK,EAAE,GAAG,GAAG,MAAM;AAClC;AAEA,SAAgB,OAAO,OAAuB;CAC5C,OAAO,GAAG,GAAG,KAAK,EAAE;AACtB"}

package/build/queries/sql/keywords.d.cts

@@ -0,0 +1,18 @@
+//#region src/queries/sql/keywords.d.ts
+/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */
+declare function kq(ident: string): string;
+/**
+ * Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or
+ * `a.column` column.
+ *
+ * `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;
+ * these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which
+ * keeps display-name keys (`select: { "Book Count": ... }`) working. Names longer than PG's 63-byte
+ * identifier limit are still rejected: PG would silently truncate them and break row decoding.
+ */
+declare function safeKq(ident: string): string;
+declare function kqDot(alias: string, column: string): string;
+declare function kqStar(alias: string): string;
+//#endregion
+export { kq, kqDot, kqStar, safeKq };
+//# sourceMappingURL=keywords.d.cts.map

package/build/queries/sql/keywords.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.cts","names":[],"sources":["../../../src/queries/sql/keywords.ts"],"mappings":";;iBA4GgB,GAAG;;;;;;;;;;iBAeH,OAAO;iBAMP,MAAM,eAAe;iBAIrB,OAAO"}

package/build/queries/sql/keywords.d.mts

@@ -0,0 +1,18 @@
+//#region src/queries/sql/keywords.d.ts
+/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */
+declare function kq(ident: string): string;
+/**
+ * Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or
+ * `a.column` column.
+ *
+ * `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;
+ * these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which
+ * keeps display-name keys (`select: { "Book Count": ... }`) working. Names longer than PG's 63-byte
+ * identifier limit are still rejected: PG would silently truncate them and break row decoding.
+ */
+declare function safeKq(ident: string): string;
+declare function kqDot(alias: string, column: string): string;
+declare function kqStar(alias: string): string;
+//#endregion
+export { kq, kqDot, kqStar, safeKq };
+//# sourceMappingURL=keywords.d.mts.map

package/build/queries/sql/keywords.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.mts","names":[],"sources":["../../../src/queries/sql/keywords.ts"],"mappings":";;iBA4GgB,GAAG;;;;;;;;;;iBAeH,OAAO;iBAMP,MAAM,eAAe;iBAIrB,OAAO"}

package/build/queries/sql/keywords.js

@@ -0,0 +1,132 @@
+//#region src/queries/sql/keywords.ts
+const escapeMapped = new Map([
+	"all",
+	"alter",
+	"analyse",
+	"analyze",
+	"and",
+	"any",
+	"array",
+	"as",
+	"asc",
+	"avg",
+	"between",
+	"by",
+	"asymmetric",
+	"both",
+	"case",
+	"count",
+	"cast",
+	"check",
+	"collate",
+	"column",
+	"constraint",
+	"create",
+	"delete",
+	"current_catalog",
+	"current_date",
+	"current_role",
+	"current_time",
+	"current_timestamp",
+	"current_user",
+	"default",
+	"deferrable",
+	"desc",
+	"distinct",
+	"drop",
+	"do",
+	"else",
+	"end",
+	"from",
+	"except",
+	"false",
+	"fetch",
+	"for",
+	"foreign",
+	"from",
+	"grant",
+	"group",
+	"having",
+	"in",
+	"inner",
+	"insert",
+	"initially",
+	"intersect",
+	"into",
+	"is",
+	"join",
+	"left",
+	"like",
+	"max",
+	"min",
+	"lateral",
+	"leading",
+	"limit",
+	"localtime",
+	"localtimestamp",
+	"not",
+	"null",
+	"offset",
+	"on",
+	"only",
+	"or",
+	"order",
+	"outer",
+	"right",
+	"placing",
+	"primary",
+	"references",
+	"returning",
+	"select",
+	"set",
+	"sum",
+	"session_user",
+	"some",
+	"symmetric",
+	"table",
+	"then",
+	"to",
+	"trailing",
+	"true",
+	"union",
+	"update",
+	"values",
+	"unique",
+	"user",
+	"using",
+	"variadic",
+	"when",
+	"where",
+	"window",
+	"with"
+].map((k) => [k, `"${k}"`]));
+const allLower = /^[a-z0-9_]+$/;
+/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */
+function kq(ident) {
+	if (!allLower.test(ident)) return `"${ident}"`;
+	return escapeMapped.get(ident) ?? ident;
+}
+/**
+* Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or
+* `a.column` column.
+*
+* `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;
+* these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which
+* keeps display-name keys (`select: { "Book Count": ... }`) working. Names longer than PG's 63-byte
+* identifier limit are still rejected: PG would silently truncate them and break row decoding.
+*/
+function safeKq(ident) {
+	if (ident.length > 63) throw new Error(`Identifier '${ident}' is longer than PG's 63-byte limit`);
+	if (!ident.includes("\"")) return kq(ident);
+	return `"${ident.replaceAll("\"", "\"\"")}"`;
+}
+function kqDot(alias, column) {
+	return `${kq(alias)}.${kq(column)}`;
+}
+function kqStar(alias) {
+	return `${kq(alias)}.*`;
+}
+//#endregion
+export { kq, kqDot, kqStar, safeKq };
+
+//# sourceMappingURL=keywords.js.map

package/build/queries/sql/keywords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.js","names":[],"sources":["../../../src/queries/sql/keywords.ts"],"sourcesContent":["// select word from pg_get_keywords() where catdesc = 'reserved' order by word;\nconst keywords = [\n  \"all\",\n  \"alter\",\n  \"analyse\",\n  \"analyze\",\n  \"and\",\n  \"any\",\n  \"array\",\n  \"as\",\n  \"asc\",\n  \"avg\",\n  \"between\",\n  \"by\",\n  \"asymmetric\",\n  \"both\",\n  \"case\",\n  \"count\",\n  \"cast\",\n  \"check\",\n  \"collate\",\n  \"column\",\n  \"constraint\",\n  \"create\",\n  \"delete\",\n  \"current_catalog\",\n  \"current_date\",\n  \"current_role\",\n  \"current_time\",\n  \"current_timestamp\",\n  \"current_user\",\n  \"default\",\n  \"deferrable\",\n  \"desc\",\n  \"distinct\",\n  \"drop\",\n  \"do\",\n  \"else\",\n  \"end\",\n  \"from\",\n  \"except\",\n  \"false\",\n  \"fetch\",\n  \"for\",\n  \"foreign\",\n  \"from\",\n  \"grant\",\n  \"group\",\n  \"having\",\n  \"in\",\n  \"inner\",\n  \"insert\",\n  \"initially\",\n  \"intersect\",\n  \"into\",\n  \"is\",\n  \"join\",\n  \"left\",\n  \"like\",\n  \"max\",\n  \"min\",\n  \"lateral\",\n  \"leading\",\n  \"limit\",\n  \"localtime\",\n  \"localtimestamp\",\n  \"not\",\n  \"null\",\n  \"offset\",\n  \"on\",\n  \"only\",\n  \"or\",\n  \"order\",\n  \"outer\",\n  \"right\",\n  \"placing\",\n  \"primary\",\n  \"references\",\n  \"returning\",\n  \"select\",\n  \"set\",\n  \"sum\",\n  \"session_user\",\n  \"some\",\n  \"symmetric\",\n  \"table\",\n  \"then\",\n  \"to\",\n  \"trailing\",\n  \"true\",\n  \"union\",\n  \"update\",\n  \"values\",\n  \"unique\",\n  \"user\",\n  \"using\",\n  \"variadic\",\n  \"when\",\n  \"where\",\n  \"window\",\n  \"with\",\n];\n\n// Cache all keywords => their escaped equivalent\nconst escapeMapped = new Map(keywords.map((k) => [k, `\"${k}\"`]));\nconst allLower = /^[a-z0-9_]+$/;\n\n/** Conditionally quotes `identifier` if it's a SQL keyword or not snake cased; for trusted idents only. */\nexport function kq(ident: string): string {\n  // All camel-cased identifiers/column names need to be quoted\n  if (!allLower.test(ident)) return `\"${ident}\"`;\n  return escapeMapped.get(ident) ?? ident;\n}\n\n/**\n * Quotes a possibly-untrusted identifier, i.e. an em.query select key, subquery `as` name, or\n * `a.column` column.\n *\n * `kq`'s inputs are trusted metadata (codegen'd table/column names), and its quoting assumes that;\n * these idents are user strings, so embedded quotes are escaped like PG's own quote_ident, which\n * keeps display-name keys (`select: { \"Book Count\": ... }`) working. Names longer than PG's 63-byte\n * identifier limit are still rejected: PG would silently truncate them and break row decoding.\n */\nexport function safeKq(ident: string): string {\n  if (ident.length > 63) throw new Error(`Identifier '${ident}' is longer than PG's 63-byte limit`);\n  if (!ident.includes('\"')) return kq(ident);\n  return `\"${ident.replaceAll('\"', '\"\"')}\"`;\n}\n\nexport function kqDot(alias: string, column: string): string {\n  return `${kq(alias)}.${kq(column)}`;\n}\n\nexport function kqStar(alias: string): string {\n  return `${kq(alias)}.*`;\n}\n"],"mappings":";AAwGA,MAAM,eAAe,IAAI,IAAI;CAtG3B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAIkC,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC;AAC/D,MAAM,WAAW;;AAGjB,SAAgB,GAAG,OAAuB;CAExC,IAAI,CAAC,SAAS,KAAK,KAAK,GAAG,OAAO,IAAI,MAAM;CAC5C,OAAO,aAAa,IAAI,KAAK,KAAK;AACpC;;;;;;;;;;AAWA,SAAgB,OAAO,OAAuB;CAC5C,IAAI,MAAM,SAAS,IAAI,MAAM,IAAI,MAAM,eAAe,MAAM,oCAAoC;CAChG,IAAI,CAAC,MAAM,SAAS,IAAG,GAAG,OAAO,GAAG,KAAK;CACzC,OAAO,IAAI,MAAM,WAAW,MAAK,MAAI,EAAE;AACzC;AAEA,SAAgB,MAAM,OAAe,QAAwB;CAC3D,OAAO,GAAG,GAAG,KAAK,EAAE,GAAG,GAAG,MAAM;AAClC;AAEA,SAAgB,OAAO,OAAuB;CAC5C,OAAO,GAAG,GAAG,KAAK,EAAE;AACtB"}