@supabase/postgrest-typegen 0.2.0 → 0.2.2

package/dist/types.js

@@ -136,6 +136,17 @@ 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 or an unconditional INSTEAD rule. Tracked separately from
+     * `is_updatable` (which mirrors `information_schema.views` and ignores
+     * triggers). Optional because version 1 metadata predating this field is
+     * still valid; consumers fall back to `is_updatable` when absent.
+     */
+    "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.2.0",
+  "version": "0.2.2",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -62,8 +62,7 @@
   },
   "dependencies": {
     "arktype": "2.2.3",
-    "oxfmt": "0.65.0",
-    "pg-format": "1.0.4"
+    "oxfmt": "0.66.0"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -72,9 +71,8 @@
     "@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",
-    "oxlint": "1.80.0",
+    "oxlint": "1.81.0",
     "oxlint-tsgolint": "7.0.2001",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",

package/src/collation.ts

@@ -0,0 +1,16 @@
+/**
+ * The one string comparison every ordering in this package uses.
+ *
+ * Generated output is ordered by name, and `String.prototype.localeCompare`
+ * without a locale follows the host's default locale, so the same database
+ * produced differently ordered code on differently configured machines (a
+ * Swedish host sorts `ä` after `z`, an English one next to `a`). Pinning the
+ * collator to English keeps the order postgres-meta's output has on the
+ * English CI runners and makes it the same everywhere else.
+ */
+const collator = new Intl.Collator("en");
+
+/** Compare two strings with the pinned English collation. */
+export function compareStrings(a: string, b: string): number {
+  return collator.compare(a, b);
+}

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/index.ts

@@ -5,6 +5,7 @@ export {
   generateTypescript,
   type GenerateTypescriptOptions,
   pgTypeToTsType,
+  type TypeResolutionContext,
 } from "./typescript.ts";
 export {
   type AccessControl,

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

@@ -7,6 +7,7 @@ import type {
   PostgresType,
   PostgresView,
 } from "../types.ts";
+import { compareStrings } from "../collation.ts";
 
 type Operation = "Select" | "Insert" | "Update";
 export type AccessControl = "internal" | "public" | "private" | "package";
@@ -174,6 +175,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 +228,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)}}`,
   ];
@@ -270,11 +314,11 @@ export const generateSwift = (
     ...schemas.flatMap((schema) => {
       const schemaTables = [...tables, ...foreignTables]
         .filter((table) => table.schema === schema.name)
-        .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+        .sort(({ name: a }, { name: b }) => compareStrings(a, b));
 
       const schemaViews = [...views, ...materializedViews]
         .filter((table) => table.schema === schema.name)
-        .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+        .sort(({ name: a }, { name: b }) => compareStrings(a, b));
 
       const schemaEnums = types.filter(
         (type) => type.schema === schema.name && type.enums.length > 0,
@@ -381,6 +425,12 @@ const pgTypeToSwiftType = (
     swiftType = "String";
   } else if (["json", "jsonb"].includes(pgType)) {
     swiftType = "AnyJSON";
+    // `void` and `record` are pseudo-types: Postgres rejects them as a column or
+    // composite attribute type ("column has pseudo-type void"), and this
+    // generator only renders columns and attributes, never functions. So these
+    // two arms are unreachable today and deliberately untested. They are kept
+    // because they are the mappings to use if Swift ever emits functions, which
+    // is where these types do appear.
   } else if (pgType === "void") {
     swiftType = "Void";
   } else if (pgType === "record") {