@supabase/postgrest-typegen 0.1.0 → 0.2.1

package/dist/types.d.ts

@@ -182,6 +182,8 @@ declare const postgresViewSchema: import("arktype/internal/variants/object.ts").
     schema: string;
     name: string;
     is_updatable: boolean;
+    is_insert_enabled: boolean;
+    is_update_enabled: boolean;
     comment: string | null;
     columns?: {
         table_id: number;
@@ -250,7 +252,9 @@ export declare const generatorMetadataSchema: import("arktype/internal/variants/
     views: {
         comment: string | null;
         id: number;
+        is_insert_enabled: boolean;
         is_updatable: boolean;
+        is_update_enabled: boolean;
         name: string;
         schema: string;
     }[];

package/dist/types.js

@@ -136,6 +136,15 @@ const postgresViewSchema = type({
     schema: "string",
     name: "string",
     is_updatable: "boolean",
+    /**
+     * Whether INSERT works through this view: auto-updatable per
+     * `pg_relation_is_updatable`, or made insertable by an INSTEAD OF INSERT
+     * trigger. Tracked separately from `is_updatable` (which mirrors
+     * `information_schema.views` and ignores triggers).
+     */
+    is_insert_enabled: "boolean",
+    /** Same as `is_insert_enabled`, for UPDATE. */
+    is_update_enabled: "boolean",
     comment: "string | null",
     "columns?": postgresColumnSchema.array(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -62,8 +62,7 @@
   },
   "dependencies": {
     "arktype": "2.2.3",
-    "pg-format": "1.0.4",
-    "prettier": "3.5.3"
+    "oxfmt": "0.65.0"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -72,9 +71,7 @@
     "@types/bun": "^1.4.0",
     "@types/node": "^26.3.0",
     "@types/pg": "^8.23.1",
-    "@types/pg-format": "^1.0.5",
     "knip": "^6.32.3",
-    "oxfmt": "0.65.0",
     "oxlint": "1.80.0",
     "oxlint-tsgolint": "7.0.2001",
     "pg": "^8.23.0",

package/src/generation/go.ts

@@ -118,6 +118,35 @@ function formatForGoTypeName(name: string): string {
     .join("");
 }
 
+/**
+ * Renders the `json` struct tag for a column or composite attribute name.
+ *
+ * The name is quoted with `JSON.stringify`, whose escape sequences are a
+ * subset of Go's, so `reflect.StructTag.Get("json")` recovers the exact name
+ * via `strconv.Unquote` even when it contains quotes, backslashes or control
+ * characters. The tag is emitted as a raw string literal like before, except
+ * when the name contains a backtick: Go raw literals cannot contain one, so
+ * such tags fall back to an interpreted literal with a second round of
+ * escaping. Names the marshaler cannot represent still compile and
+ * round-trip through `reflect.StructTag`, but `encoding/json` applies its
+ * own tag rules at runtime: a comma splits the name from tag options (so
+ * only the part before it is used as the JSON name), and a name it rejects
+ * outright (for example one containing a quote) falls back to the Go field
+ * name. That is a limitation of the struct tag convention itself, not of
+ * the generated source.
+ *
+ * @example
+ * ```ts
+ * formatForGoStructTag('name') // `json:"name"`
+ * formatForGoStructTag('a"b') // `json:"a\"b"`
+ * formatForGoStructTag('back`tick') // "json:\"back`tick\""
+ * ```
+ */
+function formatForGoStructTag(name: string): string {
+  const tag = `json:${JSON.stringify(name)}`;
+  return tag.includes("`") ? JSON.stringify(tag) : `\`${tag}\``;
+}
+
 function generateTableStruct(
   schema: PostgresSchema,
   table: PostgresTable | PostgresView | PostgresMaterializedView,
@@ -170,7 +199,7 @@ function generateTableStruct(
     ([formattedName, type, name]) => {
       return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(
         maxTypeLength,
-      )} \`json:"${name}"\``;
+      )} ${formatForGoStructTag(name)}`;
     },
   );
 
@@ -232,7 +261,7 @@ function generateCompositeTypeStruct(
     ([formattedName, type, name]) => {
       return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(
         maxTypeLength,
-      )} \`json:"${name}"\``;
+      )} ${formatForGoStructTag(name)}`;
     },
   );
 

package/src/generation/python.ts

@@ -48,13 +48,12 @@ from typing import (
     Any,
     List,
     Literal,
-    NotRequired,
     Optional,
-    TypeAlias,
     TypedDict,
 )
+from typing_extensions import NotRequired, TypeAlias
 
-from pydantic import BaseModel, Field, Json
+from pydantic import BaseModel, Field, JsonValue
 
 ${concatLines(Object.values(ctx.user_enums))}
 
@@ -143,7 +142,9 @@ class PythonContext {
     const attributeEntries: PythonBaseModelAttr[] = attributes.map(
       (attribute) => {
         const type = this.parsePgType(attribute.type!.name);
-        return new PythonBaseModelAttr(attribute.name, type, false);
+        // Composite type attributes cannot carry NOT NULL constraints in
+        // Postgres, so every field is inherently nullable.
+        return new PythonBaseModelAttr(attribute.name, type, true);
       },
     );
 
@@ -229,7 +230,9 @@ class PythonEnum implements Serializable {
     this.variants = type.enums;
   }
   serialize(): string {
-    const variants = this.variants.map((item) => `"${item}"`).join(", ");
+    const variants = this.variants
+      .map((item) => escapePythonString(item))
+      .join(", ");
     return `${this.name}: TypeAlias = Literal[${variants}]`;
   }
 }
@@ -273,7 +276,7 @@ class PythonBaseModelAttr implements Serializable {
     const py_type = this.nullable
       ? `Optional[${this.py_type.serialize()}]`
       : this.py_type.serialize();
-    return `    ${this.name}: ${py_type} = Field(alias="${this.pg_name}")`;
+    return `    ${this.name}: ${py_type} = Field(alias=${escapePythonString(this.pg_name)})`;
   }
 }
 
@@ -326,7 +329,7 @@ class PythonTypedDictAttr implements Serializable {
     const py_type = this.nullable
       ? `Optional[${this.py_type.serialize()}]`
       : this.py_type.serialize();
-    const annotation = `Annotated[${py_type}, Field(alias="${this.pg_name}")]`;
+    const annotation = `Annotated[${py_type}, Field(alias=${escapePythonString(this.pg_name)})]`;
     const rhs = this.not_required ? `NotRequired[${annotation}]` : annotation;
     return `    ${this.name}: ${rhs}`;
   }
@@ -367,6 +370,16 @@ function concatLines(items: Serializable[]): string {
   return items.map((item) => item.serialize()).join("\n\n");
 }
 
+/**
+ * Emits a Postgres name as a double-quoted Python string literal. JSON string
+ * escaping is a subset of Python's (`\"`, `\\`, `\n`, `\uXXXX`), so
+ * `JSON.stringify` yields a literal Python parses to the exact original name
+ * and keeps quotes, backslashes and newlines from breaking out of it.
+ */
+function escapePythonString(value: string): string {
+  return JSON.stringify(value);
+}
+
 const PY_TYPE_MAP: Record<string, string> = {
   // Bool
   bool: "bool",
@@ -395,9 +408,11 @@ const PY_TYPE_MAP: Record<string, string> = {
   vector: "list[Any]",
   interval: "str",
 
-  // JSON
-  json: "Json[Any]",
-  jsonb: "Json[Any]",
+  // JSON. PostgREST returns these columns already deserialized, so the
+  // generated models must accept parsed values (JsonValue), not JSON strings
+  // (which is what pydantic's Json[...] validates and parses).
+  json: "JsonValue",
+  jsonb: "JsonValue",
 
   // Range types (can be adjusted to more complex types if needed)
   int4range: "str",

package/src/generation/swift.ts

@@ -174,6 +174,49 @@ function generateProtocolConformances(protocols: string[]): string {
   return protocols.length === 0 ? "" : `: ${protocols.join(", ")}`;
 }
 
+/**
+ * Serializes a database-provided value as a Swift string literal. Backslashes
+ * would otherwise start escape or interpolation sequences (`\(`), double
+ * quotes would terminate the literal early, and line breaks or control
+ * characters are not allowed in single-line literals, so all of them are
+ * escaped per Swift's string literal grammar. U+2028 and U+2029 are legal in
+ * Swift literals but are escaped anyway because other tooling mishandles
+ * them. Swift unescapes at compile time, so raw values round-trip unchanged.
+ */
+function swiftStringLiteral(value: string): string {
+  let escaped = "";
+  for (const character of value) {
+    switch (character) {
+      case "\\":
+        escaped += "\\\\";
+        break;
+      case '"':
+        escaped += '\\"';
+        break;
+      case "\t":
+        escaped += "\\t";
+        break;
+      case "\n":
+        escaped += "\\n";
+        break;
+      case "\r":
+        escaped += "\\r";
+        break;
+      default: {
+        const codePoint = character.codePointAt(0)!;
+        escaped +=
+          codePoint < 0x20 ||
+          codePoint === 0x7f ||
+          codePoint === 0x2028 ||
+          codePoint === 0x2029
+            ? `\\u{${codePoint.toString(16)}}`
+            : character;
+      }
+    }
+  }
+  return `"${escaped}"`;
+}
+
 function generateEnum(
   enum_: SwiftEnum,
   { accessControl, level }: SwiftGeneratorOptions & { level: number },
@@ -184,7 +227,7 @@ function generateEnum(
     )} {`,
     ...enum_.cases.map(
       (case_) =>
-        `${ident(level + 1)}case ${case_.formattedName} = "${case_.rawValue}"`,
+        `${ident(level + 1)}case ${case_.formattedName} = ${swiftStringLiteral(case_.rawValue)}`,
     ),
     `${ident(level)}}`,
   ];

package/src/generation/typescript.ts

@@ -3,7 +3,7 @@
 // literals (relying on Array#toString) to build the output. Preserving that is required for
 // byte-parity, and the offending expressions sit inside template literals where a targeted
 // disable comment would corrupt the emitted string.
-import prettier from "prettier";
+import { format as oxfmtFormat } from "oxfmt";
 import type {
   GeneratorMetadata,
   PostgresColumn,
@@ -35,8 +35,30 @@ export interface GenerateTypescriptOptions {
    * env read. Default `'public'`.
    */
   defaultSchema?: string;
+  /**
+   * Formatter used on the generated output. Defaults to `oxfmt`, called
+   * inline. Callers on a latency-sensitive request path (e.g. postgres-meta's
+   * hosted `/generators/typescript` route) can substitute a worker-pool-backed
+   * formatter here instead of blocking the event loop on every call.
+   */
+  format?: (code: string) => Promise<string>;
 }
 
+const defaultFormat = async (code: string): Promise<string> => {
+  const { code: formatted, errors } = await oxfmtFormat("output.ts", code, {
+    semi: false,
+    printWidth: 80,
+  });
+  if (errors.length > 0) {
+    throw new Error(
+      `oxfmt failed to format generated TypeScript output: ${errors
+        .map((error) => error.message)
+        .join("; ")}`,
+    );
+  }
+  return formatted;
+};
+
 type TsRelationship = Pick<
   GeneratorMetadata["relationships"][number],
   | "foreign_key_name"
@@ -71,6 +93,7 @@ export const generateTypescript = async (
     detectOneToOneRelationships = false,
     postgrestVersion,
     defaultSchema = "public",
+    format = defaultFormat,
   } = opts;
   // Ordering of all collections (incl. relationships, columns, args below) is
   // provided by `sortGeneratorMetadata`; this generator no longer re-sorts.
@@ -209,6 +232,8 @@ export const generateTypescript = async (
         view: {
           ...materializedView,
           is_updatable: false,
+          is_insert_enabled: false,
+          is_update_enabled: false,
         },
         relationships: getRelationships(materializedView),
       });
@@ -524,7 +549,13 @@ export const generateTypescript = async (
   ) => {
     return fns
       .map(({ fn, inArgs }) => {
-        let argsType = "never";
+        // `never` would be wrong here: postgrest-js treats `Args extends { '': Row }`
+        // as a computed field (`never extends T` is always true, so same-named table
+        // columns get omitted from select results), and an object type with a required
+        // `never` property is uninhabited for any tool doing sound type math on the
+        // generated types. `Record<PropertyKey, never>` is the accurate type for
+        // "callable with no arguments".
+        let argsType = "Record<PropertyKey, never>";
         let returnType = getFunctionReturnType(schema, fn);
 
         // Check for specific error cases
@@ -614,6 +645,11 @@ export const generateTypescript = async (
     : "";
 
   function generateNullableUnionTsType(tsType: string, isNullable: boolean) {
+    // The generated Json type includes null, so a NOT NULL json/jsonb column
+    // has to be narrowed with NonNullable to reflect the database constraint.
+    if (tsType === "Json" && !isNullable) {
+      return `NonNullable<${tsType}>`;
+    }
     // Only add the null union if the type is not unknown as unknown already includes null
     if (tsType === "unknown" || tsType === "any" || !isNullable) {
       return tsType;
@@ -693,7 +729,10 @@ export type Database = {
                   }
                   Insert: {
                     ${columnsByTableId[table.id].map((column) => {
-                      if (column.identity_generation === "ALWAYS") {
+                      if (
+                        column.identity_generation === "ALWAYS" ||
+                        column.is_generated
+                      ) {
                         return `${JSON.stringify(column.name)}?: never`;
                       }
                       return generateColumnTsDefinition(
@@ -714,7 +753,10 @@ export type Database = {
                   }
                   Update: {
                     ${columnsByTableId[table.id].map((column) => {
-                      if (column.identity_generation === "ALWAYS") {
+                      if (
+                        column.identity_generation === "ALWAYS" ||
+                        column.is_generated
+                      ) {
                         return `${JSON.stringify(column.name)}?: never`;
                       }
 
@@ -774,7 +816,7 @@ export type Database = {
                     ]}
                   }
                   ${
-                    view.is_updatable
+                    view.is_insert_enabled
                       ? `Insert: {
                            ${columnsByTableId[view.id].map((column) => {
                              if (!column.is_updatable) {
@@ -793,7 +835,11 @@ export type Database = {
                              );
                            })}
                          }
-                         Update: {
+                        `
+                      : ""
+                  }${
+                    view.is_update_enabled
+                      ? `Update: {
                            ${columnsByTableId[view.id].map((column) => {
                              if (!column.is_updatable) {
                                return `${JSON.stringify(column.name)}?: never`;
@@ -1016,10 +1062,7 @@ export const Constants = {
 } as const
 `;
 
-  output = await prettier.format(output, {
-    parser: "typescript",
-    semi: false,
-  });
+  output = await format(output);
   return output;
 };
 

package/src/introspection/index.ts

@@ -62,45 +62,48 @@ export async function introspect(
   const queryRows = async (sql: string) =>
     normalizeRows((await db.query(sql)).rows);
 
-  const schemas = await queryRows(
-    SCHEMAS_SQL({
-      includeSystemSchemas: false,
-      nameFilter: systemExcludingFilter,
-    }),
-  );
-  const tables = await queryRows(
-    TABLES_SQL({ schemaFilter: systemExcludingFilter }),
-  );
-  const foreignTables = await queryRows(
-    FOREIGN_TABLES_SQL({ schemaFilter: plainFilter }),
-  );
-  const views = await queryRows(
-    VIEWS_SQL({ schemaFilter: systemExcludingFilter }),
-  );
-  const materializedViews = await queryRows(
-    MATERIALIZED_VIEWS_SQL({ schemaFilter: plainFilter }),
-  );
-  const columns = await queryRows(
-    COLUMNS_SQL({ schemaFilter: systemExcludingFilter }),
-  );
-  const primaryKeys = await queryRows(
-    PRIMARY_KEYS_SQL({ schemaFilter: systemExcludingFilter }),
-  );
-  const relationships = await listRelationships(db, {
-    includedSchemas: included,
-    excludedSchemas: excluded,
-  });
-  const functions = await queryRows(
-    FUNCTIONS_SQL({ schemaFilter: systemExcludingFilter }),
-  );
-  // types: includeSystemSchemas true (no schema filter), table + array types included.
-  const types = await queryRows(
-    TYPES_SQL({
-      schemaFilter: "",
-      includeTableTypes: true,
-      includeArrayTypes: true,
+  // Issued concurrently, matching postgres-meta's CLI path which ran its nine
+  // introspection queries under Promise.all. A pooled Queryable runs them in
+  // parallel; a single-connection one pipelines them, which is no worse than
+  // awaiting each in turn.
+  const [
+    schemas,
+    tables,
+    foreignTables,
+    views,
+    materializedViews,
+    columns,
+    primaryKeys,
+    relationships,
+    functions,
+    types,
+  ] = await Promise.all([
+    queryRows(
+      SCHEMAS_SQL({
+        includeSystemSchemas: false,
+        nameFilter: systemExcludingFilter,
+      }),
+    ),
+    queryRows(TABLES_SQL({ schemaFilter: systemExcludingFilter })),
+    queryRows(FOREIGN_TABLES_SQL({ schemaFilter: plainFilter })),
+    queryRows(VIEWS_SQL({ schemaFilter: systemExcludingFilter })),
+    queryRows(MATERIALIZED_VIEWS_SQL({ schemaFilter: plainFilter })),
+    queryRows(COLUMNS_SQL({ schemaFilter: systemExcludingFilter })),
+    queryRows(PRIMARY_KEYS_SQL({ schemaFilter: systemExcludingFilter })),
+    listRelationships(db, {
+      includedSchemas: included,
+      excludedSchemas: excluded,
     }),
-  );
+    queryRows(FUNCTIONS_SQL({ schemaFilter: systemExcludingFilter })),
+    // types: includeSystemSchemas true (no schema filter), table + array types included.
+    queryRows(
+      TYPES_SQL({
+        schemaFilter: "",
+        includeTableTypes: true,
+        includeArrayTypes: true,
+      }),
+    ),
+  ]);
 
   return {
     version: GENERATOR_METADATA_VERSION,

package/src/introspection/sql/columns.sql.ts

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
 
 export const COLUMNS_SQL = (
@@ -52,7 +52,24 @@ SELECT
   ) AS is_nullable,
   (
     c.relkind IN ('r', 'p')
-    OR c.relkind IN ('v', 'f') AND pg_column_is_updatable(c.oid, a.attnum, FALSE)
+    -- Columns of views made writable by INSTEAD OF triggers can be written
+    -- through PostgREST even though the view is not auto-updatable, so they
+    -- must not degrade to \`?: never\` in generated Insert/Update types.
+    -- include_triggers => TRUE covers INSTEAD OF UPDATE triggers, but
+    -- pg_column_is_updatable only considers the UPDATE event, so INSTEAD OF
+    -- INSERT triggers (tgtype bits: 64 = INSTEAD, 4 = INSERT) are checked
+    -- separately. Which events a view accepts is gated per view via
+    -- is_insert_enabled / is_update_enabled.
+    OR c.relkind IN ('v', 'f') AND (
+      pg_column_is_updatable(c.oid, a.attnum, TRUE)
+      OR EXISTS (
+        SELECT 1 FROM pg_trigger tg
+        WHERE tg.tgrelid = c.oid
+          AND tg.tgtype & 64 <> 0
+          AND tg.tgtype & 4 <> 0
+          AND NOT tg.tgisinternal
+      )
+    )
   ) AS is_updatable,
   uniques.table_id IS NOT NULL AS is_unique,
   check_constraints.definition AS "check",

package/src/introspection/sql/foreign_tables.sql.ts

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 import type { SQLQueryProps } from "./common.ts";
 
 export const FOREIGN_TABLES_SQL = (

package/src/introspection/sql/functions.sql.ts

@@ -1,7 +1,7 @@
 // oxlint-disable typescript/restrict-template-expressions -- verbatim port of postgres-meta's
 // builder, which interpolates the `args` string[] into the SQL (relying on Array#toString). The
 // expression sits inside a template literal where a targeted disable comment would corrupt the SQL.
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
 
 export const FUNCTIONS_SQL = (

package/src/introspection/sql/helpers.ts

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 
 /**
  * Schemas that postgres-meta excludes by default when `includeSystemSchemas`
@@ -13,7 +13,7 @@ export const DEFAULT_SYSTEM_SCHEMAS = [
 /**
  * Build a SQL `IN (...)` / `NOT IN (...)` fragment for an include/exclude list,
  * ported verbatim from `postgres-meta/src/lib/helpers.ts`. Values are escaped
- * with pg-format's `literal`. Returns an empty string when there is nothing to
+ * with the inlined pg-format `literal`. Returns an empty string when there is nothing to
  * filter, so callers interpolate it conditionally.
  */
 export const filterByList = (

package/src/introspection/sql/materialized_views.sql.ts

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
 
 export const MATERIALIZED_VIEWS_SQL = (

package/src/introspection/sql/pg-format.ts

@@ -0,0 +1,101 @@
+/**
+ * Minimal inline port of the `pg-format` helpers this package uses, so the
+ * package carries no runtime dependency for them (the CommonJS-only
+ * `pg-format` package is awkward to consume from ESM/bundled CLIs).
+ *
+ * Mirrors `pg-format@1.0.4` byte-for-byte for the inputs postgres-meta feeds
+ * it — in particular numbers are quoted (`literal(10)` is `'10'`), because
+ * that is what postgres-meta's SQL emits and this package is byte-parity
+ * constrained against it. The `supabase/supabase` `packages/pg-meta` port
+ * deliberately diverges here (unquoted numbers); do not "fix" this to match it.
+ *
+ * Originally ported from PostgreSQL's `src/interfaces/libpq/fe-exec.c`.
+ */
+
+/** Convert a JS ISO string to Postgres' default ISO 8601 form. */
+function formatDate(date: string): string {
+  return date.replace("T", " ").replace("Z", "+00");
+}
+
+function arrayToList(
+  useSpace: boolean,
+  array: unknown[],
+  formatter: (value: unknown) => string,
+): string {
+  let sql = useSpace ? " (" : "(";
+  for (const [index, element] of array.entries()) {
+    sql += (index === 0 ? "" : ", ") + formatter(element);
+  }
+  sql += ")";
+  return sql;
+}
+
+/**
+ * Quote a value as a SQL literal. `null`/`undefined` become `NULL`, booleans
+ * `'t'`/`'f'`, dates ISO 8601 strings, arrays comma-separated lists (nested
+ * arrays become parenthesised groups), plain objects `'…'::jsonb`, and
+ * everything else — including numbers — a single-quoted string with embedded
+ * quotes doubled. Strings containing a backslash use the `E'…'` form.
+ */
+export function literal(value?: unknown): string {
+  let text: string;
+  let explicitCast: string | undefined;
+
+  if (value === undefined || value === null) {
+    return "NULL";
+  }
+  if (value === false) {
+    return "'f'";
+  }
+  if (value === true) {
+    return "'t'";
+  }
+  if (value instanceof Date) {
+    return `'${formatDate(value.toISOString())}'`;
+  }
+  if (Array.isArray(value)) {
+    const parts: string[] = [];
+    for (const [index, element] of value.entries()) {
+      if (Array.isArray(element)) {
+        parts.push(arrayToList(index !== 0, element, literal));
+      } else {
+        parts.push(literal(element));
+      }
+    }
+    return parts.toString();
+  }
+  if (typeof value === "string") {
+    text = value;
+  } else if (typeof value === "number" || typeof value === "bigint") {
+    text = value.toString();
+  } else {
+    explicitCast = "jsonb";
+    text = JSON.stringify(value);
+  }
+
+  let hasBackslash = false;
+  let quoted = "'";
+
+  for (const c of text) {
+    if (c === "'") {
+      quoted += c + c;
+    } else if (c === "\\") {
+      quoted += c + c;
+      hasBackslash = true;
+    } else {
+      quoted += c;
+    }
+  }
+
+  quoted += "'";
+
+  if (hasBackslash) {
+    quoted = `E${quoted}`;
+  }
+
+  if (explicitCast) {
+    quoted += `::${explicitCast}`;
+  }
+
+  return quoted;
+}

package/src/introspection/sql/primary_keys.sql.ts

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.ts";
 import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
 
 export const PRIMARY_KEYS_SQL = (