@warlock.js/cascade 4.0.174 → 4.1.1

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

@@ -0,0 +1,144 @@
+import { AggregateExpression } from "../../expressions/aggregate-expressions.mjs";
+import { SqlDialectContract } from "../sql/sql-dialect.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/drivers/postgres/postgres-dialect.d.ts
+/**
+ * PostgreSQL-specific SQL dialect implementation.
+ *
+ * Provides PostgreSQL syntax for:
+ * - Parameter placeholders ($1, $2, $3...)
+ * - Identifier quoting with double quotes
+ * - JSONB operators (->, ->>, @>)
+ * - ILIKE for case-insensitive matching
+ * - RETURNING clause support
+ *
+ * @example
+ * ```typescript
+ * const dialect = new PostgresDialect();
+ *
+ * dialect.placeholder(1); // "$1"
+ * dialect.quoteIdentifier('user'); // '"user"'
+ * dialect.jsonExtract('data', 'name'); // "data"->>'name'
+ * ```
+ */
+declare class PostgresDialect implements SqlDialectContract {
+  /**
+   * Dialect name identifier.
+   */
+  readonly name: "postgres";
+  /**
+   * PostgreSQL supports the RETURNING clause for INSERT/UPDATE/DELETE.
+   */
+  readonly supportsReturning = true;
+  /**
+   * PostgreSQL uses ON CONFLICT for upsert operations.
+   */
+  readonly upsertKeyword: "ON CONFLICT";
+  /**
+   * Generate a PostgreSQL parameter placeholder.
+   *
+   * PostgreSQL uses numbered placeholders: $1, $2, $3, etc.
+   *
+   * @param index - The 1-based parameter index
+   * @returns The placeholder string (e.g., "$1")
+   */
+  placeholder(index: number): string;
+  /**
+   * Quote an identifier using PostgreSQL's double-quote syntax.
+   *
+   * Handles escaping of embedded double quotes by doubling them.
+   * This is necessary for reserved words and special characters.
+   *
+   * @param identifier - The identifier (table/column name) to quote
+   * @returns The quoted identifier (e.g., '"user"')
+   */
+  quoteIdentifier(identifier: string): string;
+  /**
+   * Convert a boolean to PostgreSQL literal.
+   *
+   * @param value - The boolean value
+   * @returns "TRUE" or "FALSE"
+   */
+  booleanLiteral(value: boolean): string;
+  /**
+   * Build LIMIT/OFFSET clause for PostgreSQL.
+   *
+   * @param limit - Maximum rows to return
+   * @param offset - Rows to skip
+   * @returns The SQL clause (e.g., "LIMIT 10 OFFSET 20")
+   */
+  limitOffset(limit?: number, offset?: number): string;
+  /**
+   * Build a JSON path extraction expression for PostgreSQL.
+   *
+   * Uses the ->> operator for text extraction from JSONB columns.
+   * Supports nested paths using chained operators.
+   *
+   * @param column - The JSONB column name
+   * @param path - The path to extract (dot notation: "user.name")
+   * @returns The SQL expression (e.g., "data"->>'user'->>'name')
+   */
+  jsonExtract(column: string, path: string): string;
+  /**
+   * Build a JSON contains expression for PostgreSQL.
+   *
+   * Uses the @> containment operator for JSONB columns.
+   *
+   * @param column - The JSONB column name
+   * @param value - The value to check for
+   * @param path - Optional path within the JSON
+   * @returns The SQL expression
+   */
+  jsonContains(column: string, value: unknown, path?: string): string;
+  /**
+   * Build a LIKE pattern expression for PostgreSQL.
+   *
+   * Uses ILIKE for case-insensitive matching, LIKE for case-sensitive.
+   *
+   * @param pattern - The pattern to match
+   * @param caseInsensitive - Whether to use case-insensitive matching
+   * @returns Object with operator and pattern
+   */
+  likePattern(pattern: string, caseInsensitive?: boolean): {
+    operator: string;
+    pattern: string;
+  };
+  /**
+   * Build an array contains expression for PostgreSQL.
+   *
+   * Uses ANY() for checking if a value is in an array column.
+   *
+   * @param column - The array column name
+   * @param paramIndex - The parameter index
+   * @returns The SQL expression
+   */
+  arrayContains(column: string, paramIndex: number): string;
+  /**
+   * Get the PostgreSQL SQL type for an abstract type.
+   *
+   * @param type - The abstract type name
+   * @param options - Type-specific options
+   * @returns The PostgreSQL type string
+   */
+  getSqlType(type: string, options?: {
+    length?: number;
+    precision?: number;
+    scale?: number;
+    dimensions?: number;
+  }): string;
+  /**
+   * Translate a database-agnostic aggregate expression to PostgreSQL SQL.
+   *
+   * The five scalar aggregates map to their ANSI SQL function. `distinct`,
+   * `floor`, `first` and `last` are MongoDB-only for v1 — none has a
+   * single-scalar `GROUP BY` equivalent on PostgreSQL, so they throw instead
+   * of emitting a silently-different semantic (the footgun this guards).
+   *
+   * @param expression - The abstract aggregate (`$agg.*`) to translate
+   * @returns The SQL fragment (e.g. `SUM("amount")`, `COUNT(*)`)
+   */
+  aggregateToSql(expression: AggregateExpression): string;
+}
+//#endregion
+export { PostgresDialect };
+//# sourceMappingURL=postgres-dialect.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-dialect.d.mts","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/drivers/postgres/postgres-dialect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAgCa,eAAA,YAA2B,kBAAkB;EA0InD;;;EAAA,SAtIW,IAAA;EAyJqB;;;EAAA,SApJrB,iBAAA;EAiKe;;;EAAA,SA5Jf,aAAA;EAyQT;;;;AAA8C;;;;EA/P9C,WAAA,CAAY,KAAA;;;;;;;;;;EAaZ,eAAA,CAAgB,UAAA;;;;;;;EAYhB,cAAA,CAAe,KAAA;;;;;;;;EAWf,WAAA,CAAY,KAAA,WAAgB,MAAA;;;;;;;;;;;EAwB5B,WAAA,CAAY,MAAA,UAAgB,IAAA;;;;;;;;;;;EA4B5B,YAAA,CAAa,MAAA,UAAgB,KAAA,WAAgB,IAAA;;;;;;;;;;EAuB7C,WAAA,CACL,OAAA,UACA,eAAA;IACG,QAAA;IAAkB,OAAA;EAAA;;;;;;;;;;EAmBhB,aAAA,CAAc,MAAA,UAAgB,UAAA;;;;;;;;EAW9B,UAAA,CACL,IAAA,UACA,OAAA;IAAY,MAAA;IAAiB,SAAA;IAAoB,KAAA;IAAgB,UAAA;EAAA;;;;;;;;;;;;EA6G5D,cAAA,CAAe,UAAA,EAAY,mBAAA;AAAA"}

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

@@ -0,0 +1,227 @@
+//#region ../../@warlock.js/cascade/src/drivers/postgres/postgres-dialect.ts
+/**
+* PostgreSQL-specific SQL dialect implementation.
+*
+* Provides PostgreSQL syntax for:
+* - Parameter placeholders ($1, $2, $3...)
+* - Identifier quoting with double quotes
+* - JSONB operators (->, ->>, @>)
+* - ILIKE for case-insensitive matching
+* - RETURNING clause support
+*
+* @example
+* ```typescript
+* const dialect = new PostgresDialect();
+*
+* dialect.placeholder(1); // "$1"
+* dialect.quoteIdentifier('user'); // '"user"'
+* dialect.jsonExtract('data', 'name'); // "data"->>'name'
+* ```
+*/
+var PostgresDialect = class {
+	/**
+	* Dialect name identifier.
+	*/
+	name = "postgres";
+	/**
+	* PostgreSQL supports the RETURNING clause for INSERT/UPDATE/DELETE.
+	*/
+	supportsReturning = true;
+	/**
+	* PostgreSQL uses ON CONFLICT for upsert operations.
+	*/
+	upsertKeyword = "ON CONFLICT";
+	/**
+	* Generate a PostgreSQL parameter placeholder.
+	*
+	* PostgreSQL uses numbered placeholders: $1, $2, $3, etc.
+	*
+	* @param index - The 1-based parameter index
+	* @returns The placeholder string (e.g., "$1")
+	*/
+	placeholder(index) {
+		return `$${index}`;
+	}
+	/**
+	* Quote an identifier using PostgreSQL's double-quote syntax.
+	*
+	* Handles escaping of embedded double quotes by doubling them.
+	* This is necessary for reserved words and special characters.
+	*
+	* @param identifier - The identifier (table/column name) to quote
+	* @returns The quoted identifier (e.g., '"user"')
+	*/
+	quoteIdentifier(identifier) {
+		return identifier.split(".").map((part) => `"${part.replace(/"/g, "\"\"")}"`).join(".");
+	}
+	/**
+	* Convert a boolean to PostgreSQL literal.
+	*
+	* @param value - The boolean value
+	* @returns "TRUE" or "FALSE"
+	*/
+	booleanLiteral(value) {
+		return value ? "TRUE" : "FALSE";
+	}
+	/**
+	* Build LIMIT/OFFSET clause for PostgreSQL.
+	*
+	* @param limit - Maximum rows to return
+	* @param offset - Rows to skip
+	* @returns The SQL clause (e.g., "LIMIT 10 OFFSET 20")
+	*/
+	limitOffset(limit, offset) {
+		const parts = [];
+		if (limit !== void 0) parts.push(`LIMIT ${limit}`);
+		if (offset !== void 0) parts.push(`OFFSET ${offset}`);
+		return parts.join(" ");
+	}
+	/**
+	* Build a JSON path extraction expression for PostgreSQL.
+	*
+	* Uses the ->> operator for text extraction from JSONB columns.
+	* Supports nested paths using chained operators.
+	*
+	* @param column - The JSONB column name
+	* @param path - The path to extract (dot notation: "user.name")
+	* @returns The SQL expression (e.g., "data"->>'user'->>'name')
+	*/
+	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]}'`;
+	}
+	/**
+	* Build a JSON contains expression for PostgreSQL.
+	*
+	* Uses the @> containment operator for JSONB columns.
+	*
+	* @param column - The JSONB column name
+	* @param value - The value to check for
+	* @param path - Optional path within the JSON
+	* @returns The SQL expression
+	*/
+	jsonContains(column, value, path) {
+		const quotedColumn = this.quoteIdentifier(column);
+		if (path) return `${quotedColumn} @> '${JSON.stringify({ [path]: value })}'::jsonb`;
+		return `${quotedColumn} @> '${JSON.stringify(value)}'::jsonb`;
+	}
+	/**
+	* Build a LIKE pattern expression for PostgreSQL.
+	*
+	* Uses ILIKE for case-insensitive matching, LIKE for case-sensitive.
+	*
+	* @param pattern - The pattern to match
+	* @param caseInsensitive - Whether to use case-insensitive matching
+	* @returns Object with operator and pattern
+	*/
+	likePattern(pattern, caseInsensitive = true) {
+		const escapedPattern = pattern.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+		return {
+			operator: caseInsensitive ? "ILIKE" : "LIKE",
+			pattern: escapedPattern
+		};
+	}
+	/**
+	* Build an array contains expression for PostgreSQL.
+	*
+	* Uses ANY() for checking if a value is in an array column.
+	*
+	* @param column - The array column name
+	* @param paramIndex - The parameter index
+	* @returns The SQL expression
+	*/
+	arrayContains(column, paramIndex) {
+		return `${this.placeholder(paramIndex)} = ANY(${this.quoteIdentifier(column)})`;
+	}
+	/**
+	* Get the PostgreSQL SQL type for an abstract type.
+	*
+	* @param type - The abstract type name
+	* @param options - Type-specific options
+	* @returns The PostgreSQL type string
+	*/
+	getSqlType(type, options) {
+		switch (type) {
+			case "string": return options?.length ? `VARCHAR(${options.length})` : "TEXT";
+			case "char": return `CHAR(${options?.length ?? 1})`;
+			case "text": return "TEXT";
+			case "mediumText":
+			case "longText": return "TEXT";
+			case "integer": return "INTEGER";
+			case "smallInteger": return "SMALLINT";
+			case "tinyInteger": return "SMALLINT";
+			case "bigInteger": return "BIGINT";
+			case "float": return "REAL";
+			case "double": return "DOUBLE PRECISION";
+			case "decimal":
+				if (options?.precision !== void 0) {
+					const scale = options.scale ?? 0;
+					return `DECIMAL(${options.precision}, ${scale})`;
+				}
+				return "DECIMAL";
+			case "boolean": return "BOOLEAN";
+			case "date": return "DATE";
+			case "dateTime": return "TIMESTAMP";
+			case "timestamp": return "TIMESTAMPTZ";
+			case "time": return "TIME";
+			case "year": return "SMALLINT";
+			case "json": return "JSONB";
+			case "binary": return "BYTEA";
+			case "uuid": return "UUID";
+			case "ulid": return "CHAR(26)";
+			case "ipAddress": return "INET";
+			case "macAddress": return "MACADDR";
+			case "point": return "POINT";
+			case "polygon": return "POLYGON";
+			case "lineString": return "PATH";
+			case "geometry": return "GEOMETRY";
+			case "vector": return options?.dimensions ? `VECTOR(${options.dimensions})` : "VECTOR";
+			case "enum": return "TEXT";
+			case "set": return "TEXT[]";
+			case "arrayInt": return "INTEGER[]";
+			case "arrayBigInt": return "BIGINT[]";
+			case "arrayFloat": return "REAL[]";
+			case "arrayDecimal":
+				if (options?.precision !== void 0) {
+					const scale = options.scale ?? 0;
+					return `DECIMAL(${options.precision}, ${scale})[]`;
+				}
+				return "DECIMAL[]";
+			case "arrayBoolean": return "BOOLEAN[]";
+			case "arrayText": return "TEXT[]";
+			case "arrayDate": return "DATE[]";
+			case "arrayTimestamp": return "TIMESTAMPTZ[]";
+			case "arrayUuid": return "UUID[]";
+			case "arrayJson": return "JSONB[]";
+			default: return type.toUpperCase();
+		}
+	}
+	/**
+	* Translate a database-agnostic aggregate expression to PostgreSQL SQL.
+	*
+	* The five scalar aggregates map to their ANSI SQL function. `distinct`,
+	* `floor`, `first` and `last` are MongoDB-only for v1 — none has a
+	* single-scalar `GROUP BY` equivalent on PostgreSQL, so they throw instead
+	* of emitting a silently-different semantic (the footgun this guards).
+	*
+	* @param expression - The abstract aggregate (`$agg.*`) to translate
+	* @returns The SQL fragment (e.g. `SUM("amount")`, `COUNT(*)`)
+	*/
+	aggregateToSql(expression) {
+		const column = expression.__field === null ? "*" : this.quoteIdentifier(expression.__field);
+		switch (expression.__agg) {
+			case "count": return "COUNT(*)";
+			case "sum": return `SUM(${column})`;
+			case "avg": return `AVG(${column})`;
+			case "min": return `MIN(${column})`;
+			case "max": return `MAX(${column})`;
+			default: throw new Error(`$agg.${expression.__agg} is MongoDB-only and not supported on a PostgreSQL groupBy. Use selectRaw / havingRaw with the equivalent SQL (window function / DISTINCT / FLOOR) if you need it here.`);
+		}
+	}
+};
+
+//#endregion
+export { PostgresDialect };
+//# sourceMappingURL=postgres-dialect.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-dialect.mjs","names":[],"sources":["../../../../../../../@warlock.js/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 } 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 five scalar aggregates map to their ANSI SQL function. `distinct`,\n   * `floor`, `first` and `last` are MongoDB-only for v1 — none has a\n   * single-scalar `GROUP BY` equivalent on PostgreSQL, so they throw instead\n   * of emitting a silently-different semantic (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    const column = expression.__field === null ? \"*\" : this.quoteIdentifier(expression.__field);\n\n    switch (expression.__agg) {\n      case \"count\":\n        return \"COUNT(*)\";\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"],"mappings":"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"}