@warlock.js/cascade 5.19.1 → 5.21.0

package/esm/drivers/postgres/postgres-dialect.mjs

@@ -72,8 +72,8 @@ var PostgresDialect = class {
 	*/
 	limitOffset(limit, offset) {
 		const parts = [];
-		if (limit !== void 0) parts.push(`LIMIT ${limit}`);
-		if (offset !== void 0) parts.push(`OFFSET ${offset}`);
+		if (limit !== void 0) parts.push(`LIMIT ${toSafeInteger(limit, "LIMIT")}`);
+		if (offset !== void 0) parts.push(`OFFSET ${toSafeInteger(offset, "OFFSET")}`);
 		return parts.join(" ");
 	}
 	/**
@@ -89,8 +89,10 @@ var PostgresDialect = class {
 	jsonExtract(column, path) {
 		const quotedColumn = this.quoteIdentifier(column);
 		const pathParts = path.split(".");
-		if (pathParts.length === 1) return `${quotedColumn}->>'${pathParts[0]}'`;
-		return `${quotedColumn}->${pathParts.slice(0, -1).map((p) => `'${p}'`).join("->")}->>'${pathParts[pathParts.length - 1]}'`;
+		if (pathParts.length === 1) return `${quotedColumn}->>'${escapeSqlLiteral(pathParts[0])}'`;
+		const jsonPath = pathParts.slice(0, -1).map((p) => `'${escapeSqlLiteral(p)}'`).join("->");
+		const lastKey = pathParts[pathParts.length - 1];
+		return `${quotedColumn}->${jsonPath}->>'${escapeSqlLiteral(lastKey)}'`;
 	}
 	/**
 	* Build a JSON contains expression for PostgreSQL.
@@ -104,8 +106,8 @@ var PostgresDialect = class {
 	*/
 	jsonContains(column, value, path) {
 		const quotedColumn = this.quoteIdentifier(column);
-		if (path) return `${quotedColumn} @> '${JSON.stringify({ [path]: value })}'::jsonb`;
-		return `${quotedColumn} @> '${JSON.stringify(value)}'::jsonb`;
+		if (path) return `${quotedColumn} @> '${escapeSqlLiteral(JSON.stringify({ [path]: value }))}'::jsonb`;
+		return `${quotedColumn} @> '${escapeSqlLiteral(JSON.stringify(value))}'::jsonb`;
 	}
 	/**
 	* Build a LIKE pattern expression for PostgreSQL.
@@ -240,7 +242,7 @@ var PostgresDialect = class {
 	columnExpressionToSql(expression) {
 		switch (expression.__expr) {
 			case "column": return this.quoteIdentifier(expression.column);
-			case "literal": return typeof expression.value === "boolean" ? this.booleanLiteral(expression.value) : String(expression.value);
+			case "literal": return typeof expression.value === "boolean" ? this.booleanLiteral(expression.value) : String(toFiniteNumber(expression.value));
 			case "raw": return expression.expression;
 			case "add":
 			case "subtract":
@@ -271,10 +273,38 @@ var PostgresDialect = class {
 	* ```
 	*/
 	dateTruncSql(column, unit) {
+		if (![
+			"day",
+			"week",
+			"month",
+			"year"
+		].includes(unit)) throw new Error(`PostgresDialect: invalid date_trunc unit "${unit}"`);
 		return `date_trunc('${unit}', ${this.quoteIdentifier(column)})`;
 	}
 };
+/**
+* Escape a string for use inside a single-quoted SQL literal (`'` doubled).
+*/
+function escapeSqlLiteral(value) {
+	return String(value).replace(/'/g, "''");
+}
+/**
+* Coerce a LIMIT/OFFSET value to a non-negative safe integer or throw.
+* Numeric strings (e.g. from query params) are accepted; anything else is not.
+*/
+function toSafeInteger(value, label) {
+	const number = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+	if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) throw new Error(`PostgresDialect: ${label} must be a non-negative safe integer`);
+	return number;
+}
+/**
+* Literals in column expressions are emitted verbatim, so only finite numbers pass.
+*/
+function toFiniteNumber(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error("PostgresDialect: column expression literal must be a finite number or boolean");
+	return value;
+}
 
 //#endregion
-export { PostgresDialect };
+export { PostgresDialect, escapeSqlLiteral };
 //# sourceMappingURL=postgres-dialect.mjs.map

package/esm/drivers/postgres/postgres-dialect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-dialect.mjs","names":[],"sources":["../../../../../../../../cascade/src/drivers/postgres/postgres-dialect.ts"],"sourcesContent":["/**\n * PostgreSQL Dialect Implementation\n *\n * Implements the SqlDialectContract for PostgreSQL-specific SQL syntax.\n * Handles parameter placeholders ($1, $2), identifier quoting, and\n * PostgreSQL-specific features like JSONB operators.\n *\n * @module cascade/drivers/postgres\n */\n\nimport type { AggregateExpression, ColumnExpression } from \"../../expressions\";\nimport type { SqlDialectContract } from \"../sql/sql-dialect.contract\";\n\n/**\n * PostgreSQL-specific SQL dialect implementation.\n *\n * Provides PostgreSQL syntax for:\n * - Parameter placeholders ($1, $2, $3...)\n * - Identifier quoting with double quotes\n * - JSONB operators (->, ->>, @>)\n * - ILIKE for case-insensitive matching\n * - RETURNING clause support\n *\n * @example\n * ```typescript\n * const dialect = new PostgresDialect();\n *\n * dialect.placeholder(1); // \"$1\"\n * dialect.quoteIdentifier('user'); // '\"user\"'\n * dialect.jsonExtract('data', 'name'); // \"data\"->>'name'\n * ```\n */\nexport class PostgresDialect implements SqlDialectContract {\n  /**\n   * Dialect name identifier.\n   */\n  public readonly name = \"postgres\" as const;\n\n  /**\n   * PostgreSQL supports the RETURNING clause for INSERT/UPDATE/DELETE.\n   */\n  public readonly supportsReturning = true;\n\n  /**\n   * PostgreSQL uses ON CONFLICT for upsert operations.\n   */\n  public readonly upsertKeyword = \"ON CONFLICT\" as const;\n\n  /**\n   * Generate a PostgreSQL parameter placeholder.\n   *\n   * PostgreSQL uses numbered placeholders: $1, $2, $3, etc.\n   *\n   * @param index - The 1-based parameter index\n   * @returns The placeholder string (e.g., \"$1\")\n   */\n  public placeholder(index: number): string {\n    return `$${index}`;\n  }\n\n  /**\n   * Quote an identifier using PostgreSQL's double-quote syntax.\n   *\n   * Handles escaping of embedded double quotes by doubling them.\n   * This is necessary for reserved words and special characters.\n   *\n   * @param identifier - The identifier (table/column name) to quote\n   * @returns The quoted identifier (e.g., '\"user\"')\n   */\n  public quoteIdentifier(identifier: string): string {\n    // Split on dots for qualified names (schema.table.column)\n    const parts = identifier.split(\".\");\n    return parts.map((part) => `\"${part.replace(/\"/g, '\"\"')}\"`).join(\".\");\n  }\n\n  /**\n   * Convert a boolean to PostgreSQL literal.\n   *\n   * @param value - The boolean value\n   * @returns \"TRUE\" or \"FALSE\"\n   */\n  public booleanLiteral(value: boolean): string {\n    return value ? \"TRUE\" : \"FALSE\";\n  }\n\n  /**\n   * Build LIMIT/OFFSET clause for PostgreSQL.\n   *\n   * @param limit - Maximum rows to return\n   * @param offset - Rows to skip\n   * @returns The SQL clause (e.g., \"LIMIT 10 OFFSET 20\")\n   */\n  public limitOffset(limit?: number, offset?: number): string {\n    const parts: string[] = [];\n\n    if (limit !== undefined) {\n      parts.push(`LIMIT ${limit}`);\n    }\n\n    if (offset !== undefined) {\n      parts.push(`OFFSET ${offset}`);\n    }\n\n    return parts.join(\" \");\n  }\n\n  /**\n   * Build a JSON path extraction expression for PostgreSQL.\n   *\n   * Uses the ->> operator for text extraction from JSONB columns.\n   * Supports nested paths using chained operators.\n   *\n   * @param column - The JSONB column name\n   * @param path - The path to extract (dot notation: \"user.name\")\n   * @returns The SQL expression (e.g., \"data\"->>'user'->>'name')\n   */\n  public jsonExtract(column: string, path: string): string {\n    const quotedColumn = this.quoteIdentifier(column);\n    const pathParts = path.split(\".\");\n\n    if (pathParts.length === 1) {\n      return `${quotedColumn}->>'${pathParts[0]}'`;\n    }\n\n    // For nested paths: data->'user'->>'name' (last one gets text extraction)\n    const jsonPath = pathParts\n      .slice(0, -1)\n      .map((p) => `'${p}'`)\n      .join(\"->\");\n    const lastKey = pathParts[pathParts.length - 1];\n\n    return `${quotedColumn}->${jsonPath}->>'${lastKey}'`;\n  }\n\n  /**\n   * Build a JSON contains expression for PostgreSQL.\n   *\n   * Uses the @> containment operator for JSONB columns.\n   *\n   * @param column - The JSONB column name\n   * @param value - The value to check for\n   * @param path - Optional path within the JSON\n   * @returns The SQL expression\n   */\n  public jsonContains(column: string, value: unknown, path?: string): string {\n    const quotedColumn = this.quoteIdentifier(column);\n\n    if (path) {\n      // Check if a specific path contains the value\n      const jsonValue = JSON.stringify({ [path]: value });\n      return `${quotedColumn} @> '${jsonValue}'::jsonb`;\n    }\n\n    // Check if the column contains the value (for arrays or objects)\n    const jsonValue = JSON.stringify(value);\n    return `${quotedColumn} @> '${jsonValue}'::jsonb`;\n  }\n\n  /**\n   * Build a LIKE pattern expression for PostgreSQL.\n   *\n   * Uses ILIKE for case-insensitive matching, LIKE for case-sensitive.\n   *\n   * @param pattern - The pattern to match\n   * @param caseInsensitive - Whether to use case-insensitive matching\n   * @returns Object with operator and pattern\n   */\n  public likePattern(\n    pattern: string,\n    caseInsensitive = true,\n  ): { operator: string; pattern: string } {\n    // Escape special characters in the pattern (%, _, \\)\n    const escapedPattern = pattern.replace(/\\\\/g, \"\\\\\\\\\").replace(/%/g, \"\\\\%\").replace(/_/g, \"\\\\_\");\n\n    return {\n      operator: caseInsensitive ? \"ILIKE\" : \"LIKE\",\n      pattern: escapedPattern,\n    };\n  }\n\n  /**\n   * Build an array contains expression for PostgreSQL.\n   *\n   * Uses ANY() for checking if a value is in an array column.\n   *\n   * @param column - The array column name\n   * @param paramIndex - The parameter index\n   * @returns The SQL expression\n   */\n  public arrayContains(column: string, paramIndex: number): string {\n    return `${this.placeholder(paramIndex)} = ANY(${this.quoteIdentifier(column)})`;\n  }\n\n  /**\n   * Get the PostgreSQL SQL type for an abstract type.\n   *\n   * @param type - The abstract type name\n   * @param options - Type-specific options\n   * @returns The PostgreSQL type string\n   */\n  public getSqlType(\n    type: string,\n    options?: { length?: number; precision?: number; scale?: number; dimensions?: number },\n  ): string {\n    switch (type) {\n      case \"string\":\n        return options?.length ? `VARCHAR(${options.length})` : \"TEXT\";\n      case \"char\":\n        return `CHAR(${options?.length ?? 1})`;\n      case \"text\":\n        return \"TEXT\";\n      case \"mediumText\":\n      case \"longText\":\n        return \"TEXT\"; // PostgreSQL doesn't distinguish text sizes\n      case \"integer\":\n        return \"INTEGER\";\n      case \"smallInteger\":\n        return \"SMALLINT\";\n      case \"tinyInteger\":\n        return \"SMALLINT\"; // PostgreSQL doesn't have TINYINT\n      case \"bigInteger\":\n        return \"BIGINT\";\n      case \"float\":\n        return \"REAL\";\n      case \"double\":\n        return \"DOUBLE PRECISION\";\n      case \"decimal\":\n        if (options?.precision !== undefined) {\n          const scale = options.scale ?? 0;\n          return `DECIMAL(${options.precision}, ${scale})`;\n        }\n        return \"DECIMAL\";\n      case \"boolean\":\n        return \"BOOLEAN\";\n      case \"date\":\n        return \"DATE\";\n      case \"dateTime\":\n        return \"TIMESTAMP\";\n      case \"timestamp\":\n        return \"TIMESTAMPTZ\"; // With timezone\n      case \"time\":\n        return \"TIME\";\n      case \"year\":\n        return \"SMALLINT\"; // PostgreSQL doesn't have YEAR type\n      case \"json\":\n        return \"JSONB\"; // Prefer JSONB for indexing and operators\n      case \"binary\":\n        return \"BYTEA\";\n      case \"uuid\":\n        return \"UUID\";\n      case \"ulid\":\n        return \"CHAR(26)\"; // ULIDs are 26 characters\n      case \"ipAddress\":\n        return \"INET\";\n      case \"macAddress\":\n        return \"MACADDR\";\n      case \"point\":\n        return \"POINT\";\n      case \"polygon\":\n        return \"POLYGON\";\n      case \"lineString\":\n        return \"PATH\";\n      case \"geometry\":\n        return \"GEOMETRY\"; // Requires PostGIS\n      case \"vector\":\n        return options?.dimensions ? `VECTOR(${options.dimensions})` : \"VECTOR\"; // Requires pgvector\n      case \"enum\":\n        return \"TEXT\"; // PostgreSQL enums need CREATE TYPE first\n      case \"set\":\n        return \"TEXT[]\"; // Use array for set-like behavior\n      // PostgreSQL native array types\n      case \"arrayInt\":\n        return \"INTEGER[]\";\n      case \"arrayBigInt\":\n        return \"BIGINT[]\";\n      case \"arrayFloat\":\n        return \"REAL[]\";\n      case \"arrayDecimal\":\n        if (options?.precision !== undefined) {\n          const scale = options.scale ?? 0;\n          return `DECIMAL(${options.precision}, ${scale})[]`;\n        }\n        return \"DECIMAL[]\";\n      case \"arrayBoolean\":\n        return \"BOOLEAN[]\";\n      case \"arrayText\":\n        return \"TEXT[]\";\n      case \"arrayDate\":\n        return \"DATE[]\";\n      case \"arrayTimestamp\":\n        return \"TIMESTAMPTZ[]\";\n      case \"arrayUuid\":\n        return \"UUID[]\";\n      case \"arrayJson\":\n        return \"JSONB[]\";\n      default:\n        return type.toUpperCase();\n    }\n  }\n\n  /**\n   * Translate a database-agnostic aggregate expression to PostgreSQL SQL.\n   *\n   * The scalar aggregates map to their ANSI SQL function, and `countDistinct`\n   * maps to `COUNT(DISTINCT …)`. `distinct`, `floor`, `first` and `last` are\n   * MongoDB-only for v1 — none has a single-scalar `GROUP BY` equivalent on\n   * PostgreSQL, so they throw instead of emitting a silently-different semantic\n   * (the footgun this guards).\n   *\n   * @param expression - The abstract aggregate (`$agg.*`) to translate\n   * @returns The SQL fragment (e.g. `SUM(\"amount\")`, `COUNT(*)`)\n   */\n  public aggregateToSql(expression: AggregateExpression): string {\n    // When a composed column expression is present, the aggregate operates on\n    // it instead of a bare column (e.g. SUM(price * quantity)). Only `sum`\n    // supports the expression form in v1.\n    if (expression.__expr) {\n      if (expression.__agg !== \"sum\") {\n        throw new Error(\n          `$agg.${expression.__agg} does not support a composed column ` +\n            `expression yet — only $agg.sum(...) does. Use a bare column name here.`,\n        );\n      }\n\n      return `SUM(${this.columnExpressionToSql(expression.__expr)})`;\n    }\n\n    const column = expression.__field === null ? \"*\" : this.quoteIdentifier(expression.__field);\n\n    switch (expression.__agg) {\n      case \"count\":\n        return \"COUNT(*)\";\n      case \"countDistinct\":\n        return `COUNT(DISTINCT ${column})`;\n      case \"sum\":\n        return `SUM(${column})`;\n      case \"avg\":\n        return `AVG(${column})`;\n      case \"min\":\n        return `MIN(${column})`;\n      case \"max\":\n        return `MAX(${column})`;\n      default:\n        throw new Error(\n          `$agg.${expression.__agg} is MongoDB-only and not supported on a ` +\n            `PostgreSQL groupBy. Use selectRaw / havingRaw with the equivalent ` +\n            `SQL (window function / DISTINCT / FLOOR) if you need it here.`,\n        );\n    }\n  }\n\n  /**\n   * Compile a typed {@link ColumnExpression} tree into a SQL fragment.\n   *\n   * Column references flow through {@link quoteIdentifier} (so user-supplied\n   * names are quoted/escaped, never raw-interpolated); literals are emitted as\n   * numeric/boolean SQL constants; arithmetic ops are parenthesised. The `raw`\n   * node is the only path that emits a string verbatim — it is opt-in by name.\n   *\n   * @param expression - The expression tree to compile\n   * @returns A SQL fragment (e.g. `(\"price\" * \"quantity\")`)\n   */\n  public columnExpressionToSql(expression: ColumnExpression): string {\n    switch (expression.__expr) {\n      case \"column\":\n        return this.quoteIdentifier(expression.column);\n      case \"literal\":\n        return typeof expression.value === \"boolean\"\n          ? this.booleanLiteral(expression.value)\n          : String(expression.value);\n      case \"raw\":\n        return expression.expression;\n      case \"add\":\n      case \"subtract\":\n      case \"multiply\":\n      case \"divide\": {\n        const operator = { add: \"+\", subtract: \"-\", multiply: \"*\", divide: \"/\" }[expression.__expr];\n        const parts = expression.operands.map((operand) => this.columnExpressionToSql(operand));\n        return `(${parts.join(` ${operator} `)})`;\n      }\n      default:\n        throw new Error(`Unsupported column expression node: ${JSON.stringify(expression)}`);\n    }\n  }\n\n  /**\n   * Build a `date_trunc` bucket expression for a portable `groupByDate`.\n   *\n   * @param column - The date/timestamp column to truncate\n   * @param unit - The bucket granularity\n   * @returns The SQL fragment (e.g. `date_trunc('month', \"created_at\")`)\n   *\n   * @example\n   * ```typescript\n   * dialect.dateTruncSql(\"created_at\", \"month\");\n   * // date_trunc('month', \"created_at\")\n   * ```\n   */\n  public dateTruncSql(column: string, unit: \"day\" | \"week\" | \"month\" | \"year\"): string {\n    return `date_trunc('${unit}', ${this.quoteIdentifier(column)})`;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"postgres-dialect.mjs","names":[],"sources":["../../../../../../../../cascade/src/drivers/postgres/postgres-dialect.ts"],"sourcesContent":["/**\n * PostgreSQL Dialect Implementation\n *\n * Implements the SqlDialectContract for PostgreSQL-specific SQL syntax.\n * Handles parameter placeholders ($1, $2), identifier quoting, and\n * PostgreSQL-specific features like JSONB operators.\n *\n * @module cascade/drivers/postgres\n */\n\nimport type { AggregateExpression, ColumnExpression } from \"../../expressions\";\nimport type { SqlDialectContract } from \"../sql/sql-dialect.contract\";\n\n/**\n * PostgreSQL-specific SQL dialect implementation.\n *\n * Provides PostgreSQL syntax for:\n * - Parameter placeholders ($1, $2, $3...)\n * - Identifier quoting with double quotes\n * - JSONB operators (->, ->>, @>)\n * - ILIKE for case-insensitive matching\n * - RETURNING clause support\n *\n * @example\n * ```typescript\n * const dialect = new PostgresDialect();\n *\n * dialect.placeholder(1); // \"$1\"\n * dialect.quoteIdentifier('user'); // '\"user\"'\n * dialect.jsonExtract('data', 'name'); // \"data\"->>'name'\n * ```\n */\nexport class PostgresDialect implements SqlDialectContract {\n  /**\n   * Dialect name identifier.\n   */\n  public readonly name = \"postgres\" as const;\n\n  /**\n   * PostgreSQL supports the RETURNING clause for INSERT/UPDATE/DELETE.\n   */\n  public readonly supportsReturning = true;\n\n  /**\n   * PostgreSQL uses ON CONFLICT for upsert operations.\n   */\n  public readonly upsertKeyword = \"ON CONFLICT\" as const;\n\n  /**\n   * Generate a PostgreSQL parameter placeholder.\n   *\n   * PostgreSQL uses numbered placeholders: $1, $2, $3, etc.\n   *\n   * @param index - The 1-based parameter index\n   * @returns The placeholder string (e.g., \"$1\")\n   */\n  public placeholder(index: number): string {\n    return `$${index}`;\n  }\n\n  /**\n   * Quote an identifier using PostgreSQL's double-quote syntax.\n   *\n   * Handles escaping of embedded double quotes by doubling them.\n   * This is necessary for reserved words and special characters.\n   *\n   * @param identifier - The identifier (table/column name) to quote\n   * @returns The quoted identifier (e.g., '\"user\"')\n   */\n  public quoteIdentifier(identifier: string): string {\n    // Split on dots for qualified names (schema.table.column)\n    const parts = identifier.split(\".\");\n    return parts.map((part) => `\"${part.replace(/\"/g, '\"\"')}\"`).join(\".\");\n  }\n\n  /**\n   * Convert a boolean to PostgreSQL literal.\n   *\n   * @param value - The boolean value\n   * @returns \"TRUE\" or \"FALSE\"\n   */\n  public booleanLiteral(value: boolean): string {\n    return value ? \"TRUE\" : \"FALSE\";\n  }\n\n  /**\n   * Build LIMIT/OFFSET clause for PostgreSQL.\n   *\n   * @param limit - Maximum rows to return\n   * @param offset - Rows to skip\n   * @returns The SQL clause (e.g., \"LIMIT 10 OFFSET 20\")\n   */\n  public limitOffset(limit?: number, offset?: number): string {\n    const parts: string[] = [];\n\n    if (limit !== undefined) {\n      parts.push(`LIMIT ${toSafeInteger(limit, \"LIMIT\")}`);\n    }\n\n    if (offset !== undefined) {\n      parts.push(`OFFSET ${toSafeInteger(offset, \"OFFSET\")}`);\n    }\n\n    return parts.join(\" \");\n  }\n\n  /**\n   * Build a JSON path extraction expression for PostgreSQL.\n   *\n   * Uses the ->> operator for text extraction from JSONB columns.\n   * Supports nested paths using chained operators.\n   *\n   * @param column - The JSONB column name\n   * @param path - The path to extract (dot notation: \"user.name\")\n   * @returns The SQL expression (e.g., \"data\"->>'user'->>'name')\n   */\n  public jsonExtract(column: string, path: string): string {\n    const quotedColumn = this.quoteIdentifier(column);\n    const pathParts = path.split(\".\");\n\n    if (pathParts.length === 1) {\n      return `${quotedColumn}->>'${escapeSqlLiteral(pathParts[0] as string)}'`;\n    }\n\n    // For nested paths: data->'user'->>'name' (last one gets text extraction)\n    const jsonPath = pathParts\n      .slice(0, -1)\n      .map((p) => `'${escapeSqlLiteral(p)}'`)\n      .join(\"->\");\n    const lastKey = pathParts[pathParts.length - 1];\n\n    return `${quotedColumn}->${jsonPath}->>'${escapeSqlLiteral(lastKey as string)}'`;\n  }\n\n  /**\n   * Build a JSON contains expression for PostgreSQL.\n   *\n   * Uses the @> containment operator for JSONB columns.\n   *\n   * @param column - The JSONB column name\n   * @param value - The value to check for\n   * @param path - Optional path within the JSON\n   * @returns The SQL expression\n   */\n  public jsonContains(column: string, value: unknown, path?: string): string {\n    const quotedColumn = this.quoteIdentifier(column);\n\n    if (path) {\n      // Check if a specific path contains the value\n      const jsonValue = JSON.stringify({ [path]: value });\n      return `${quotedColumn} @> '${escapeSqlLiteral(jsonValue)}'::jsonb`;\n    }\n\n    // Check if the column contains the value (for arrays or objects)\n    const jsonValue = JSON.stringify(value);\n    return `${quotedColumn} @> '${escapeSqlLiteral(jsonValue)}'::jsonb`;\n  }\n\n  /**\n   * Build a LIKE pattern expression for PostgreSQL.\n   *\n   * Uses ILIKE for case-insensitive matching, LIKE for case-sensitive.\n   *\n   * @param pattern - The pattern to match\n   * @param caseInsensitive - Whether to use case-insensitive matching\n   * @returns Object with operator and pattern\n   */\n  public likePattern(\n    pattern: string,\n    caseInsensitive = true,\n  ): { operator: string; pattern: string } {\n    // Escape special characters in the pattern (%, _, \\)\n    const escapedPattern = pattern.replace(/\\\\/g, \"\\\\\\\\\").replace(/%/g, \"\\\\%\").replace(/_/g, \"\\\\_\");\n\n    return {\n      operator: caseInsensitive ? \"ILIKE\" : \"LIKE\",\n      pattern: escapedPattern,\n    };\n  }\n\n  /**\n   * Build an array contains expression for PostgreSQL.\n   *\n   * Uses ANY() for checking if a value is in an array column.\n   *\n   * @param column - The array column name\n   * @param paramIndex - The parameter index\n   * @returns The SQL expression\n   */\n  public arrayContains(column: string, paramIndex: number): string {\n    return `${this.placeholder(paramIndex)} = ANY(${this.quoteIdentifier(column)})`;\n  }\n\n  /**\n   * Get the PostgreSQL SQL type for an abstract type.\n   *\n   * @param type - The abstract type name\n   * @param options - Type-specific options\n   * @returns The PostgreSQL type string\n   */\n  public getSqlType(\n    type: string,\n    options?: { length?: number; precision?: number; scale?: number; dimensions?: number },\n  ): string {\n    switch (type) {\n      case \"string\":\n        return options?.length ? `VARCHAR(${options.length})` : \"TEXT\";\n      case \"char\":\n        return `CHAR(${options?.length ?? 1})`;\n      case \"text\":\n        return \"TEXT\";\n      case \"mediumText\":\n      case \"longText\":\n        return \"TEXT\"; // PostgreSQL doesn't distinguish text sizes\n      case \"integer\":\n        return \"INTEGER\";\n      case \"smallInteger\":\n        return \"SMALLINT\";\n      case \"tinyInteger\":\n        return \"SMALLINT\"; // PostgreSQL doesn't have TINYINT\n      case \"bigInteger\":\n        return \"BIGINT\";\n      case \"float\":\n        return \"REAL\";\n      case \"double\":\n        return \"DOUBLE PRECISION\";\n      case \"decimal\":\n        if (options?.precision !== undefined) {\n          const scale = options.scale ?? 0;\n          return `DECIMAL(${options.precision}, ${scale})`;\n        }\n        return \"DECIMAL\";\n      case \"boolean\":\n        return \"BOOLEAN\";\n      case \"date\":\n        return \"DATE\";\n      case \"dateTime\":\n        return \"TIMESTAMP\";\n      case \"timestamp\":\n        return \"TIMESTAMPTZ\"; // With timezone\n      case \"time\":\n        return \"TIME\";\n      case \"year\":\n        return \"SMALLINT\"; // PostgreSQL doesn't have YEAR type\n      case \"json\":\n        return \"JSONB\"; // Prefer JSONB for indexing and operators\n      case \"binary\":\n        return \"BYTEA\";\n      case \"uuid\":\n        return \"UUID\";\n      case \"ulid\":\n        return \"CHAR(26)\"; // ULIDs are 26 characters\n      case \"ipAddress\":\n        return \"INET\";\n      case \"macAddress\":\n        return \"MACADDR\";\n      case \"point\":\n        return \"POINT\";\n      case \"polygon\":\n        return \"POLYGON\";\n      case \"lineString\":\n        return \"PATH\";\n      case \"geometry\":\n        return \"GEOMETRY\"; // Requires PostGIS\n      case \"vector\":\n        return options?.dimensions ? `VECTOR(${options.dimensions})` : \"VECTOR\"; // Requires pgvector\n      case \"enum\":\n        return \"TEXT\"; // PostgreSQL enums need CREATE TYPE first\n      case \"set\":\n        return \"TEXT[]\"; // Use array for set-like behavior\n      // PostgreSQL native array types\n      case \"arrayInt\":\n        return \"INTEGER[]\";\n      case \"arrayBigInt\":\n        return \"BIGINT[]\";\n      case \"arrayFloat\":\n        return \"REAL[]\";\n      case \"arrayDecimal\":\n        if (options?.precision !== undefined) {\n          const scale = options.scale ?? 0;\n          return `DECIMAL(${options.precision}, ${scale})[]`;\n        }\n        return \"DECIMAL[]\";\n      case \"arrayBoolean\":\n        return \"BOOLEAN[]\";\n      case \"arrayText\":\n        return \"TEXT[]\";\n      case \"arrayDate\":\n        return \"DATE[]\";\n      case \"arrayTimestamp\":\n        return \"TIMESTAMPTZ[]\";\n      case \"arrayUuid\":\n        return \"UUID[]\";\n      case \"arrayJson\":\n        return \"JSONB[]\";\n      default:\n        return type.toUpperCase();\n    }\n  }\n\n  /**\n   * Translate a database-agnostic aggregate expression to PostgreSQL SQL.\n   *\n   * The scalar aggregates map to their ANSI SQL function, and `countDistinct`\n   * maps to `COUNT(DISTINCT …)`. `distinct`, `floor`, `first` and `last` are\n   * MongoDB-only for v1 — none has a single-scalar `GROUP BY` equivalent on\n   * PostgreSQL, so they throw instead of emitting a silently-different semantic\n   * (the footgun this guards).\n   *\n   * @param expression - The abstract aggregate (`$agg.*`) to translate\n   * @returns The SQL fragment (e.g. `SUM(\"amount\")`, `COUNT(*)`)\n   */\n  public aggregateToSql(expression: AggregateExpression): string {\n    // When a composed column expression is present, the aggregate operates on\n    // it instead of a bare column (e.g. SUM(price * quantity)). Only `sum`\n    // supports the expression form in v1.\n    if (expression.__expr) {\n      if (expression.__agg !== \"sum\") {\n        throw new Error(\n          `$agg.${expression.__agg} does not support a composed column ` +\n            `expression yet — only $agg.sum(...) does. Use a bare column name here.`,\n        );\n      }\n\n      return `SUM(${this.columnExpressionToSql(expression.__expr)})`;\n    }\n\n    const column = expression.__field === null ? \"*\" : this.quoteIdentifier(expression.__field);\n\n    switch (expression.__agg) {\n      case \"count\":\n        return \"COUNT(*)\";\n      case \"countDistinct\":\n        return `COUNT(DISTINCT ${column})`;\n      case \"sum\":\n        return `SUM(${column})`;\n      case \"avg\":\n        return `AVG(${column})`;\n      case \"min\":\n        return `MIN(${column})`;\n      case \"max\":\n        return `MAX(${column})`;\n      default:\n        throw new Error(\n          `$agg.${expression.__agg} is MongoDB-only and not supported on a ` +\n            `PostgreSQL groupBy. Use selectRaw / havingRaw with the equivalent ` +\n            `SQL (window function / DISTINCT / FLOOR) if you need it here.`,\n        );\n    }\n  }\n\n  /**\n   * Compile a typed {@link ColumnExpression} tree into a SQL fragment.\n   *\n   * Column references flow through {@link quoteIdentifier} (so user-supplied\n   * names are quoted/escaped, never raw-interpolated); literals are emitted as\n   * numeric/boolean SQL constants; arithmetic ops are parenthesised. The `raw`\n   * node is the only path that emits a string verbatim — it is opt-in by name.\n   *\n   * @param expression - The expression tree to compile\n   * @returns A SQL fragment (e.g. `(\"price\" * \"quantity\")`)\n   */\n  public columnExpressionToSql(expression: ColumnExpression): string {\n    switch (expression.__expr) {\n      case \"column\":\n        return this.quoteIdentifier(expression.column);\n      case \"literal\":\n        return typeof expression.value === \"boolean\"\n          ? this.booleanLiteral(expression.value)\n          : String(toFiniteNumber(expression.value));\n      case \"raw\":\n        return expression.expression;\n      case \"add\":\n      case \"subtract\":\n      case \"multiply\":\n      case \"divide\": {\n        const operator = { add: \"+\", subtract: \"-\", multiply: \"*\", divide: \"/\" }[expression.__expr];\n        const parts = expression.operands.map((operand) => this.columnExpressionToSql(operand));\n        return `(${parts.join(` ${operator} `)})`;\n      }\n      default:\n        throw new Error(`Unsupported column expression node: ${JSON.stringify(expression)}`);\n    }\n  }\n\n  /**\n   * Build a `date_trunc` bucket expression for a portable `groupByDate`.\n   *\n   * @param column - The date/timestamp column to truncate\n   * @param unit - The bucket granularity\n   * @returns The SQL fragment (e.g. `date_trunc('month', \"created_at\")`)\n   *\n   * @example\n   * ```typescript\n   * dialect.dateTruncSql(\"created_at\", \"month\");\n   * // date_trunc('month', \"created_at\")\n   * ```\n   */\n  public dateTruncSql(column: string, unit: \"day\" | \"week\" | \"month\" | \"year\"): string {\n    if (![\"day\", \"week\", \"month\", \"year\"].includes(unit)) {\n      throw new Error(`PostgresDialect: invalid date_trunc unit \"${unit}\"`);\n    }\n\n    return `date_trunc('${unit}', ${this.quoteIdentifier(column)})`;\n  }\n}\n\n/**\n * Escape a string for use inside a single-quoted SQL literal (`'` doubled).\n */\nexport function escapeSqlLiteral(value: string): string {\n  return String(value).replace(/'/g, \"''\");\n}\n\n/**\n * Coerce a LIMIT/OFFSET value to a non-negative safe integer or throw.\n * Numeric strings (e.g. from query params) are accepted; anything else is not.\n */\nfunction toSafeInteger(value: unknown, label: string): number {\n  const number = typeof value === \"string\" && /^\\d+$/.test(value) ? Number(value) : value;\n\n  if (typeof number !== \"number\" || !Number.isSafeInteger(number) || number < 0) {\n    throw new Error(`PostgresDialect: ${label} must be a non-negative safe integer`);\n  }\n\n  return number;\n}\n\n/**\n * Literals in column expressions are emitted verbatim, so only finite numbers pass.\n */\nfunction toFiniteNumber(value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\"PostgresDialect: column expression literal must be a finite number or boolean\");\n  }\n\n  return value;\n}\n"],"mappings":"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"}

package/esm/drivers/postgres/postgres-driver.d.mts

@@ -33,35 +33,6 @@ type PgPoolConfig = import("pg").PoolConfig;
  * without a live database.
  */
 declare function buildPostgresPoolConfig(config: PostgresPoolConfig): PgPoolConfig;
-/**
- * PostgreSQL database driver implementing the Cascade DriverContract.
- *
- * Provides connection pooling, CRUD operations, transactions, and
- * integration with Cascade's query builder and migration systems.
- *
- * @example
- * ```typescript
- * const driver = new PostgresDriver({
- *   host: 'localhost',
- *   port: 5432,
- *   database: 'myapp',
- *   user: 'postgres',
- *   password: 'secret'
- * });
- *
- * await driver.connect();
- *
- * // Insert a document
- * const result = await driver.insert('users', { name: 'Alice', email: 'alice@example.com' });
- *
- * // Query using the query builder
- * const users = await driver.queryBuilder('users')
- *   .where('name', 'Alice')
- *   .get();
- *
- * await driver.disconnect();
- * ```
- */
 declare class PostgresDriver implements DriverContract {
   private readonly config;
   /**
@@ -115,6 +86,8 @@ declare class PostgresDriver implements DriverContract {
    * @see PostgresPoolConfig.nativeArrayColumns
    */
   private readonly _nativeArrayColumns;
+  /** Column `dataTypeID`s per result row, filled by `query()` for `deserialize()`. */
+  private readonly rowColumnTypes;
   /** Unique keys per table, resolved from `pg_index` for upsert conflict targets. */
   private readonly _uniqueKeys;
   /**
@@ -227,6 +200,13 @@ declare class PostgresDriver implements DriverContract {
    * `nativeArrayColumns` config override.
    */
   private isNativeArrayColumn;
+  /**
+   * Drop the cached unique keys and re-read the native-array columns.
+   *
+   * Called by the migration driver after DDL so an in-process migration is
+   * visible to the serializer and to upserts without reconnecting.
+   */
+  invalidateSchemaCaches(): Promise<void>;
   /**
    * Introspect the live schema for native-array columns so array values bind
    * correctly with zero app configuration.
@@ -451,9 +431,29 @@ declare class PostgresDriver implements DriverContract {
   /**
    * Get the sync adapter for bulk denormalized updates.
    *
+   * Sync instructions arrive in the portable Mongo shape (`$set` with a `field.$`
+   * positional key, `$pull`, `$unset`, dotted filter keys), so they are translated
+   * to jsonb SQL here instead of being handed to `updateMany`, which would quote
+   * `"tags.$"` as a column name.
+   *
    * @returns Sync adapter instance
    */
   syncAdapter(): SyncAdapterContract;
+  /**
+   * Execute one sync instruction as a jsonb UPDATE.
+   *
+   * @param instruction - Sync instruction in the portable Mongo shape
+   * @returns Number of affected rows
+   */
+  private executeSyncInstruction;
+  /**
+   * Translate a sync instruction to a jsonb UPDATE statement.
+   *
+   * @param instruction - Sync instruction
+   * @returns SQL and parameters
+   * @throws Error for update operators a sync cannot express
+   */
+  private buildSyncStatement;
   /**
    * Get the migration driver for schema operations.
    *
@@ -465,6 +465,17 @@ declare class PostgresDriver implements DriverContract {
    * Used by Migration.toSQL() to convert pending operations to SQL strings.
    */
   getSQLSerializer(): SQLSerializer;
+  /**
+   * Whether an active transaction can be joined: one exists and it is not
+   * owned by a different data source (sessions opened outside `transaction()`
+   * carry no owner tag and are joinable).
+   */
+  private canJoinActiveTransaction;
+  /**
+   * The ambient transaction session, only when it belongs to this driver's
+   * data source.
+   */
+  private getOwnSession;
   /**
    * Execute a raw SQL query.
    *
@@ -474,6 +485,7 @@ declare class PostgresDriver implements DriverContract {
    * @param params - Query parameters
    * @returns Query result
    */
+  private recordColumnTypes;
   query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<PostgresQueryResult<T>>;
   /**
    * Emit an event to all registered listeners.
@@ -524,6 +536,17 @@ declare class PostgresDriver implements DriverContract {
    * @throws UnsupportedUpdateOperationError for operations SQL cannot express
    */
   private buildUpdateQuery;
+  /**
+   * Build the `<head> WHERE ...` statement for a single-row UPDATE/DELETE.
+   *
+   * A filter pinned to the primary key (`id = <value>`) already matches at most
+   * one row, so it is used as-is: a ctid subquery would re-check a stale tuple
+   * after waiting on a concurrent write and silently update 0 rows.
+   * Without a PK, the ctid subquery locks its candidate with
+   * `FOR UPDATE SKIP LOCKED` so concurrent callers claim different rows
+   * instead of losing the write.
+   */
+  private singleRowTarget;
   /**
    * Create a new database.
    *

package/esm/drivers/postgres/postgres-driver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-driver.d.mts","names":[],"sources":["../../../../../../../../cascade/src/drivers/postgres/postgres-driver.ts"],"mappings":"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"}
+{"version":3,"file":"postgres-driver.d.mts","names":[],"sources":["../../../../../../../../cascade/src/drivers/postgres/postgres-driver.ts"],"mappings":"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"}