@supabase/postgrest-typegen 0.1.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.d.ts

@@ -16,6 +16,13 @@ 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>;
 }
 /**
  * Does not re-sort collections; pass input pre-sorted with

package/dist/generation/typescript.js

@@ -3,8 +3,20 @@
 // 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 { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./constants.js";
+const defaultFormat = async (code) => {
+    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;
+};
 /**
  * Does not re-sort collections; pass input pre-sorted with
  * `sortGeneratorMetadata` first. Still merge-sorts tables+foreign tables and
@@ -13,7 +25,7 @@ import { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./c
  */
 export const generateTypescript = async (metadata, opts = {}) => {
     const { schemas, tables, foreignTables, views, materializedViews, columns, relationships, functions, types, } = metadata;
-    const { detectOneToOneRelationships = false, postgrestVersion, defaultSchema = "public", } = opts;
+    const { 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.
     const introspectionBySchema = Object.fromEntries(schemas.map((s) => [
@@ -111,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),
             });
@@ -339,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);
@@ -410,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;
@@ -449,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, {
@@ -465,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, {
@@ -500,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) {
@@ -515,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`;
@@ -705,10 +734,7 @@ export const Constants = {
     })}
 } as const
 `;
-    output = await prettier.format(output, {
-        parser: "typescript",
-        semi: false,
-    });
+    output = await format(output);
     return output;
 };
 // TODO: Make this more robust. Currently doesn't handle range types - returns them as unknown.

package/dist/introspection/index.js

@@ -32,27 +32,33 @@ export async function introspect(db, opts = {}) {
     const systemExcludingFilter = filterByList(included, excluded, DEFAULT_SYSTEM_SCHEMAS);
     const plainFilter = filterByList(included, excluded);
     const queryRows = async (sql) => 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,
         schemas: schemas.filter(({ name }) => !excludedSchemas.includes(name) &&

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