@supabase/postgrest-typegen 0.2.0 → 0.2.2

package/src/introspection/sql/views_key_dependencies.sql.ts

@@ -1,7 +1,8 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
+import { literal } from "./pg-format.ts";
 
 export const VIEWS_KEY_DEPENDENCIES_SQL = (
-  props: SQLQueryPropsWithSchemaFilter,
+  props: SchemaFilterProps,
 ) => /* SQL */ `
 -- Adapted from
 -- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
@@ -47,81 +48,7 @@ views as (
 transform_json as (
   select
     view_id, view_schema, view_name,
-    -- the following formatting is without indentation on purpose
-    -- to allow simple diffs, with less whitespace noise
-    replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      regexp_replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-      replace(
-        view_definition::text,
-      -- This conversion to json is heavily optimized for performance.
-      -- The general idea is to use as few regexp_replace() calls as possible.
-      -- Simple replace() is a lot faster, so we jump through some hoops
-      -- to be able to use regexp_replace() only once.
-      -- This has been tested against a huge schema with 250+ different views.
-      -- The unit tests do NOT reflect all possible inputs. Be careful when changing this!
-      -- -----------------------------------------------
-      -- pattern           | replacement         | flags
-      -- -----------------------------------------------
-      -- <> in pg_node_tree is the same as null in JSON, but due to very poor performance of json_typeof
-      -- we need to make this an empty array here to prevent json_array_elements from throwing an error
-      -- when the targetList is null.
-      -- We'll need to put it first, to make the node protection below work for node lists that start with
-      -- null: (<> ..., too. This is the case for coldefexprs, when the first column does not have a default value.
-         '<>'              , '()'
-      -- , is not part of the pg_node_tree format, but used in the regex.
-      -- This removes all , that might be part of column names.
-      ), ','               , ''
-      -- The same applies for { and }, although those are used a lot in pg_node_tree.
-      -- We remove the escaped ones, which might be part of column names again.
-      ), E'\\\\{'            , ''
-      ), E'\\\\}'            , ''
-      -- The fields we need are formatted as json manually to protect them from the regex.
-      ), ' :targetList '   , ',"targetList":'
-      ), ' :resno '        , ',"resno":'
-      ), ' :resorigtbl '   , ',"resorigtbl":'
-      ), ' :resorigcol '   , ',"resorigcol":'
-      -- Make the regex also match the node type, e.g. \`{QUERY ...\`, to remove it in one pass.
-      ), '{'               , '{ :'
-      -- Protect node lists, which start with \`({\` or \`((\` from the greedy regex.
-      -- The extra \`{\` is removed again later.
-      ), '(('              , '{(('
-      ), '({'              , '{({'
-      -- This regex removes all unused fields to avoid the need to format all of them correctly.
-      -- This leads to a smaller json result as well.
-      -- Removal stops at \`,\` for used fields (see above) and \`}\` for the end of the current node.
-      -- Nesting can't be parsed correctly with a regex, so we stop at \`{\` as well and
-      -- add an empty key for the followig node.
-      ), ' :[^}{,]+'       , ',"":'              , 'g'
-      -- For performance, the regex also added those empty keys when hitting a \`,\` or \`}\`.
-      -- Those are removed next.
-      ), ',"":}'           , '}'
-      ), ',"":,'           , ','
-      -- This reverses the "node list protection" from above.
-      ), '{('              , '('
-      -- Every key above has been added with a \`,\` so far. The first key in an object doesn't need it.
-      ), '{,'              , '{'
-      -- pg_node_tree has \`()\` around lists, but JSON uses \`[]\`
-      ), '('               , '['
-      ), ')'               , ']'
-      -- pg_node_tree has \` \` between list items, but JSON uses \`,\`
-      ), ' '             , ','
-    )::json as view_definition
+${nodeTreeToJson("view_definition::text")}::json as view_definition
   from views
 ),
 target_entries as(
@@ -197,3 +124,82 @@ group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conn
 -- make sure we only return key for which all columns are referenced in the view - no partial PKs or FKs
 having ncol = array_length(array_agg(row(col.attname, view_columns) order by pks_fks.ord), 1)
 `;
+
+/**
+ * One text rewrite of the `pg_node_tree` to JSON conversion: a `replace`, or
+ * a global `regexp_replace` when `isRegex` is set.
+ */
+type NodeTreeRewrite = {
+  pattern: string;
+  replacement: string;
+  isRegex?: boolean;
+};
+
+/**
+ * The rewrites, innermost first, that turn the `pg_node_tree` text of a view
+ * definition into JSON exposing only `targetList`, `resno`, `resorigtbl` and
+ * `resorigcol`. Ported from PostgREST's schema cache query, which keeps them
+ * as plain `replace` calls with a single `regexp_replace` for speed; the
+ * order matters, and the comments carry PostgREST's reasoning.
+ */
+const NODE_TREE_TO_JSON_REWRITES: readonly NodeTreeRewrite[] = [
+  // `<>` is pg_node_tree's null. json_typeof is too slow to special-case it,
+  // so it becomes an empty list, which also keeps the node protection below
+  // working for lists that start with null, such as coldefexprs whose first
+  // column has no default.
+  { pattern: "<>", replacement: "()" },
+  // `,`, `{` and `}` are used by the JSON conversion; drop the ones that may
+  // be part of column names (`{` and `}` are escaped there).
+  { pattern: ",", replacement: "" },
+  { pattern: "\\{", replacement: "" },
+  { pattern: "\\}", replacement: "" },
+  // Format the fields we need as JSON keys so the regex below leaves them.
+  { pattern: " :targetList ", replacement: ',"targetList":' },
+  { pattern: " :resno ", replacement: ',"resno":' },
+  { pattern: " :resorigtbl ", replacement: ',"resorigtbl":' },
+  { pattern: " :resorigcol ", replacement: ',"resorigcol":' },
+  // Make the regex also match the node type, e.g. `{QUERY ...`.
+  { pattern: "{", replacement: "{ :" },
+  // Protect node lists, which start with `({` or `((`, from the greedy regex.
+  // The extra `{` is removed again below.
+  { pattern: "((", replacement: "{((" },
+  { pattern: "({", replacement: "{({" },
+  // Remove every unused field. Removal stops at `,` for the kept fields, at
+  // `}` for the end of the node and at `{` for a nested node, leaving an empty
+  // key for the following node.
+  { pattern: " :[^}{,]+", replacement: ',"":', isRegex: true },
+  // The regex also added those empty keys before `}` and `,`.
+  { pattern: ',"":}', replacement: "}" },
+  { pattern: ',"":,', replacement: "," },
+  // Undo the node list protection.
+  { pattern: "{(", replacement: "(" },
+  // Every key was added with a leading `,`; the first key of an object does
+  // not need it.
+  { pattern: "{,", replacement: "{" },
+  // pg_node_tree lists use `( )` with space separated items; JSON uses `[ ]`
+  // with commas.
+  { pattern: "(", replacement: "[" },
+  { pattern: ")", replacement: "]" },
+  { pattern: " ", replacement: "," },
+];
+
+/**
+ * Render {@link NODE_TREE_TO_JSON_REWRITES} applied to `expression` as nested
+ * SQL calls: the opening calls stacked, then each rewrite's arguments on the
+ * line that closes it.
+ */
+function nodeTreeToJson(expression: string): string {
+  const lines = NODE_TREE_TO_JSON_REWRITES.toReversed().map(
+    (rewrite) => `    ${rewrite.isRegex ? "regexp_replace" : "replace"}(`,
+  );
+  lines.push(`      ${expression},`);
+  NODE_TREE_TO_JSON_REWRITES.forEach((rewrite, index) => {
+    const flags = rewrite.isRegex ? ", 'g'" : "";
+    const closing =
+      index === NODE_TREE_TO_JSON_REWRITES.length - 1 ? ")" : "),";
+    lines.push(
+      `      ${literal(rewrite.pattern)}, ${literal(rewrite.replacement)}${flags}${closing}`,
+    );
+  });
+  return lines.join("\n");
+}

package/src/sort.ts

@@ -26,6 +26,7 @@
  * addressed by name (the generated type is an object), matching TypeScript.
  */
 import type { GeneratorMetadata, PostgresRelationship } from "./types.ts";
+import { compareStrings } from "./collation.ts";
 
 // Relations (tables/views/materialized views/foreign tables) and types share a
 // (schema, name) identity within a database; `id` breaks any residual tie.
@@ -33,8 +34,8 @@ const bySchemaName = (
   a: { schema: string; name: string; id: number },
   b: { schema: string; name: string; id: number },
 ): number =>
-  a.schema.localeCompare(b.schema) ||
-  a.name.localeCompare(b.name) ||
+  compareStrings(a.schema, b.schema) ||
+  compareStrings(a.name, b.name) ||
   a.id - b.id;
 
 // Mirrors the TypeScript generator's historical `relationships.sort`.
@@ -42,9 +43,10 @@ const byRelationship = (
   a: PostgresRelationship,
   b: PostgresRelationship,
 ): number =>
-  a.foreign_key_name.localeCompare(b.foreign_key_name) ||
-  a.referenced_relation.localeCompare(b.referenced_relation) ||
-  JSON.stringify(a.referenced_columns).localeCompare(
+  compareStrings(a.foreign_key_name, b.foreign_key_name) ||
+  compareStrings(a.referenced_relation, b.referenced_relation) ||
+  compareStrings(
+    JSON.stringify(a.referenced_columns),
     JSON.stringify(b.referenced_columns),
   );
 
@@ -60,7 +62,7 @@ export function sortGeneratorMetadata(
   return {
     version: metadata.version,
     schemas: [...metadata.schemas].sort(
-      (a, b) => a.name.localeCompare(b.name) || a.id - b.id,
+      (a, b) => compareStrings(a.name, b.name) || a.id - b.id,
     ),
     tables: [...metadata.tables].sort(bySchemaName),
     foreignTables: [...metadata.foreignTables].sort(bySchemaName),
@@ -70,17 +72,17 @@ export function sortGeneratorMetadata(
     // (matches the TypeScript generator's per-table `columns.sort(by name)`).
     columns: [...metadata.columns].sort(
       (a, b) =>
-        a.schema.localeCompare(b.schema) ||
-        a.table.localeCompare(b.table) ||
-        a.name.localeCompare(b.name),
+        compareStrings(a.schema, b.schema) ||
+        compareStrings(a.table, b.table) ||
+        compareStrings(a.name, b.name),
     ),
     // Grouped by table like `columns`; within a table the SQL's declared
     // column order (`array_position(indkey, attnum)`) is preserved by the
     // stable sort, since composite key order is meaningful.
     primaryKeys: [...metadata.primaryKeys].sort(
       (a, b) =>
-        a.schema.localeCompare(b.schema) ||
-        a.table_name.localeCompare(b.table_name),
+        compareStrings(a.schema, b.schema) ||
+        compareStrings(a.table_name, b.table_name),
     ),
     relationships: [...metadata.relationships].sort(byRelationship),
     // Functions can overload, so the signature is part of the identity. Args
@@ -88,14 +90,17 @@ export function sortGeneratorMetadata(
     functions: [...metadata.functions]
       .sort(
         (a, b) =>
-          a.schema.localeCompare(b.schema) ||
-          a.name.localeCompare(b.name) ||
-          a.identity_argument_types.localeCompare(b.identity_argument_types) ||
+          compareStrings(a.schema, b.schema) ||
+          compareStrings(a.name, b.name) ||
+          compareStrings(
+            a.identity_argument_types,
+            b.identity_argument_types,
+          ) ||
           a.id - b.id,
       )
       .map((fn) => ({
         ...fn,
-        args: [...fn.args].sort((a, b) => a.name.localeCompare(b.name)),
+        args: [...fn.args].sort((a, b) => compareStrings(a.name, b.name)),
       })),
     types: [...metadata.types].sort(bySchemaName),
   };

package/src/types.ts

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