@supabase/postgrest-typegen 0.0.1 → 0.2.0

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) => [
@@ -705,10 +717,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/package.json

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

package/src/generation/typescript.ts

@@ -3,7 +3,7 @@
 // literals (relying on Array#toString) to build the output. Preserving that is required for
 // byte-parity, and the offending expressions sit inside template literals where a targeted
 // disable comment would corrupt the emitted string.
-import prettier from "prettier";
+import { format as oxfmtFormat } from "oxfmt";
 import type {
   GeneratorMetadata,
   PostgresColumn,
@@ -35,8 +35,30 @@ export interface GenerateTypescriptOptions {
    * env read. Default `'public'`.
    */
   defaultSchema?: string;
+  /**
+   * Formatter used on the generated output. Defaults to `oxfmt`, called
+   * inline. Callers on a latency-sensitive request path (e.g. postgres-meta's
+   * hosted `/generators/typescript` route) can substitute a worker-pool-backed
+   * formatter here instead of blocking the event loop on every call.
+   */
+  format?: (code: string) => Promise<string>;
 }
 
+const defaultFormat = async (code: string): Promise<string> => {
+  const { code: formatted, errors } = await oxfmtFormat("output.ts", code, {
+    semi: false,
+    printWidth: 80,
+  });
+  if (errors.length > 0) {
+    throw new Error(
+      `oxfmt failed to format generated TypeScript output: ${errors
+        .map((error) => error.message)
+        .join("; ")}`,
+    );
+  }
+  return formatted;
+};
+
 type TsRelationship = Pick<
   GeneratorMetadata["relationships"][number],
   | "foreign_key_name"
@@ -71,6 +93,7 @@ export const generateTypescript = async (
     detectOneToOneRelationships = false,
     postgrestVersion,
     defaultSchema = "public",
+    format = defaultFormat,
   } = opts;
   // Ordering of all collections (incl. relationships, columns, args below) is
   // provided by `sortGeneratorMetadata`; this generator no longer re-sorts.
@@ -1016,10 +1039,7 @@ export const Constants = {
 } as const
 `;
 
-  output = await prettier.format(output, {
-    parser: "typescript",
-    semi: false,
-  });
+  output = await format(output);
   return output;
 };
 

package/src/introspection/index.ts

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