@supabase/postgrest-typegen 0.2.0 → 0.2.1

package/README.md

@@ -128,6 +128,10 @@ Not yet published; consumed in-repo for now (`packages/postgrest-typegen`).
 npm install pg
 ```
 
+## Releasing
+
+Unlike the rest of this repo, merging a change here does not open a release pull request on its own. Releases are cut on demand: run the `Release postgrest-typegen` workflow from the Actions tab, which runs release-please against `release-please-config.postgrest-typegen.json` and opens (or updates) the release pull request for this package. Merging that pull request tags the release and publishes to npm.
+
 ## License
 
 MIT

package/dist/generation/go.js

@@ -58,6 +58,34 @@ function formatForGoTypeName(name) {
     })
         .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) {
+    const tag = `json:${JSON.stringify(name)}`;
+    return tag.includes("`") ? JSON.stringify(tag) : `\`${tag}\``;
+}
 function generateTableStruct(schema, table, columns, types, operation) {
     // Storing columns as a tuple of [formattedName, type, name] rather than creating the string
     // representation of the line allows us to pre-format the entries. Go formats
@@ -97,7 +125,7 @@ function generateTableStruct(schema, table, columns, types, operation) {
     // Pad the formatted name and type to align the struct fields, then join
     // create the final string representation of the struct fields.
     const formattedColumnEntries = columnEntries.map(([formattedName, type, name]) => {
-        return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(maxTypeLength)} \`json:"${name}"\``;
+        return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(maxTypeLength)} ${formatForGoStructTag(name)}`;
     });
     return `
 type ${formatForGoTypeName(schema.name)}${formatForGoTypeName(table.name)}${operation} struct {
@@ -134,7 +162,7 @@ function generateCompositeTypeStruct(schema, type, types) {
     // Pad the formatted name and type to align the struct fields, then join
     // create the final string representation of the struct fields.
     const formattedAttributeEntries = attributeEntries.map(([formattedName, type, name]) => {
-        return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(maxTypeLength)} \`json:"${name}"\``;
+        return `  ${formattedName.padEnd(maxFormattedNameLength)} ${type.padEnd(maxTypeLength)} ${formatForGoStructTag(name)}`;
     });
     return `
 type ${formatForGoTypeName(schema.name)}${formatForGoTypeName(type.name)} struct {

package/dist/generation/python.js

@@ -26,13 +26,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))}
 
@@ -100,7 +99,9 @@ class PythonContext {
         });
         const attributeEntries = 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);
         });
         const schema = this.schemas[type.schema];
         return new PythonBaseModel(type.name, schema, attributeEntries);
@@ -146,7 +147,9 @@ class PythonEnum {
         this.variants = type.enums;
     }
     serialize() {
-        const variants = this.variants.map((item) => `"${item}"`).join(", ");
+        const variants = this.variants
+            .map((item) => escapePythonString(item))
+            .join(", ");
         return `${this.name}: TypeAlias = Literal[${variants}]`;
     }
 }
@@ -183,7 +186,7 @@ class PythonBaseModelAttr {
         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)})`;
     }
 }
 class PythonBaseModel {
@@ -221,7 +224,7 @@ class PythonTypedDictAttr {
         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}`;
     }
@@ -251,6 +254,15 @@ class PythonTypedDict {
 function concatLines(items) {
     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) {
+    return JSON.stringify(value);
+}
 const PY_TYPE_MAP = {
     // Bool
     bool: "bool",
@@ -276,9 +288,11 @@ const PY_TYPE_MAP = {
     uuid: "uuid.UUID",
     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",
     int4multirange: "str",

package/dist/generation/swift.js

@@ -94,10 +94,52 @@ function pgCompositeTypeToSwiftStruct(type, { types, views, tables, }) {
 function generateProtocolConformances(protocols) {
     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) {
+    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_, { accessControl, level }) {
     return [
         `${ident(level)}${accessControl} enum ${enum_.formattedEnumName}${generateProtocolConformances(enum_.protocolConformances)} {`,
-        ...enum_.cases.map((case_) => `${ident(level + 1)}case ${case_.formattedName} = "${case_.rawValue}"`),
+        ...enum_.cases.map((case_) => `${ident(level + 1)}case ${case_.formattedName} = ${swiftStringLiteral(case_.rawValue)}`),
         `${ident(level)}}`,
     ];
 }

package/dist/generation/typescript.js

@@ -123,6 +123,8 @@ export const generateTypescript = async (metadata, opts = {}) => {
                 view: {
                     ...materializedView,
                     is_updatable: false,
+                    is_insert_enabled: false,
+                    is_update_enabled: false,
                 },
                 relationships: getRelationships(materializedView),
             });
@@ -351,7 +353,13 @@ export const generateTypescript = async (metadata, opts = {}) => {
     const getFunctionSignatures = (schema, fns) => {
         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
             const conflictError = getConflictError(schema, fns, fn, inArgs);
@@ -422,6 +430,11 @@ export const generateTypescript = async (metadata, opts = {}) => {
   }`
         : "";
     function generateNullableUnionTsType(tsType, isNullable) {
+        // 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;
@@ -461,7 +474,8 @@ 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(schema, {
@@ -477,7 +491,8 @@ 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`;
                 }
                 return generateColumnTsDefinition(schema, {
@@ -512,7 +527,7 @@ export type Database = {
                     .map(({ fn }) => `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`),
             ]}
                   }
-                  ${view.is_updatable
+                  ${view.is_insert_enabled
                 ? `Insert: {
                            ${columnsByTableId[view.id].map((column) => {
                     if (!column.is_updatable) {
@@ -527,7 +542,9 @@ export type Database = {
                     }, { types, schemas, tables, views });
                 })}
                          }
-                         Update: {
+                        `
+                : ""}${view.is_update_enabled
+                ? `Update: {
                            ${columnsByTableId[view.id].map((column) => {
                     if (!column.is_updatable) {
                         return `${JSON.stringify(column.name)}?: never`;

package/dist/introspection/sql/columns.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const COLUMNS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.columns
 
@@ -43,7 +43,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/dist/introspection/sql/foreign_tables.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const FOREIGN_TABLES_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,

package/dist/introspection/sql/functions.sql.js

@@ -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.js";
 export const FUNCTIONS_SQL = (props) => /* SQL */ `
 -- CTE with sane arg_modes, arg_names, and arg_types.
 -- All three are always of the same length.

package/dist/introspection/sql/helpers.d.ts

@@ -6,7 +6,7 @@ export declare const DEFAULT_SYSTEM_SCHEMAS: string[];
 /**
  * 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 declare const filterByList: (include?: (string | number)[], exclude?: (string | number)[], defaultExclude?: (string | number)[]) => string;

package/dist/introspection/sql/helpers.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 /**
  * Schemas that postgres-meta excludes by default when `includeSystemSchemas`
  * is false. Ported from `postgres-meta/src/lib/constants.ts`.
@@ -11,7 +11,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 = (include, exclude, defaultExclude) => {

package/dist/introspection/sql/materialized_views.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const MATERIALIZED_VIEWS_SQL = (props) => /* SQL */ `
 select
   c.oid::int8 as id,

package/dist/introspection/sql/pg-format.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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`.
+ */
+/**
+ * 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 declare function literal(value?: unknown): string;

package/dist/introspection/sql/pg-format.js

@@ -0,0 +1,92 @@
+/**
+ * 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) {
+    return date.replace("T", " ").replace("Z", "+00");
+}
+function arrayToList(useSpace, array, formatter) {
+    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) {
+    let text;
+    let explicitCast;
+    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 = [];
+        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/dist/introspection/sql/primary_keys.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const PRIMARY_KEYS_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS table_id,

package/dist/introspection/sql/schemas.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const SCHEMAS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.schemata
 select

package/dist/introspection/sql/table.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const TABLES_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,

package/dist/introspection/sql/types.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const TYPES_SQL = (props) => /* SQL */ `
 select
   t.oid::int8 as id,

package/dist/introspection/sql/views.sql.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 export const VIEWS_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -6,6 +6,12 @@ SELECT
   c.relname AS name,
   -- See definition of information_schema.views
   (pg_relation_is_updatable(c.oid, false) & 20) = 20 AS is_updatable,
+  -- Passing include_triggers => true also counts views made writable by
+  -- INSTEAD OF triggers (and INSTEAD rules), which PostgREST can write
+  -- through even when the view is not auto-updatable. Bit 8 is INSERT,
+  -- bit 4 is UPDATE (see information_schema.views).
+  (pg_relation_is_updatable(c.oid, true) & 8) = 8 AS is_insert_enabled,
+  (pg_relation_is_updatable(c.oid, true) & 4) = 4 AS is_update_enabled,
   obj_description(c.oid) AS comment
 FROM
   pg_class c

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.2.0",
+  "version": "0.2.1",
   "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.65.0"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -72,7 +71,6 @@
     "@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-tsgolint": "7.0.2001",

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

@@ -232,6 +232,8 @@ export const generateTypescript = async (
         view: {
           ...materializedView,
           is_updatable: false,
+          is_insert_enabled: false,
+          is_update_enabled: false,
         },
         relationships: getRelationships(materializedView),
       });
@@ -547,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
@@ -637,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;
@@ -716,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(
@@ -737,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`;
                       }
 
@@ -797,7 +816,7 @@ export type Database = {
                     ]}
                   }
                   ${
-                    view.is_updatable
+                    view.is_insert_enabled
                       ? `Insert: {
                            ${columnsByTableId[view.id].map((column) => {
                              if (!column.is_updatable) {
@@ -816,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`;

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 = (

package/src/introspection/sql/schemas.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 SCHEMAS_SQL = (

package/src/introspection/sql/table.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 TABLES_SQL = (

package/src/introspection/sql/types.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 TYPES_SQL = (

package/src/introspection/sql/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 VIEWS_SQL = (
@@ -12,6 +12,12 @@ SELECT
   c.relname AS name,
   -- See definition of information_schema.views
   (pg_relation_is_updatable(c.oid, false) & 20) = 20 AS is_updatable,
+  -- Passing include_triggers => true also counts views made writable by
+  -- INSTEAD OF triggers (and INSTEAD rules), which PostgREST can write
+  -- through even when the view is not auto-updatable. Bit 8 is INSERT,
+  -- bit 4 is UPDATE (see information_schema.views).
+  (pg_relation_is_updatable(c.oid, true) & 8) = 8 AS is_insert_enabled,
+  (pg_relation_is_updatable(c.oid, true) & 4) = 4 AS is_update_enabled,
   obj_description(c.oid) AS comment
 FROM
   pg_class c

package/src/types.ts

@@ -156,6 +156,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(),
 });