@supabase/pg-delta 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/cli/utils/integrations.d.ts

@@ -3,9 +3,10 @@
  */
 import type { IntegrationDSL } from "../../core/integrations/integration-dsl.ts";
 /**
- * Load an integration DSL from a JSON file.
- * If the path ends with .json, treats it as a file path directly.
- * Otherwise, tries to load from core/integrations/ first, then falls back to treating as a file path.
+ * Load an integration DSL from a file or core integration.
+ * If the path ends with .json, treats it as a JSON file path directly.
+ * Otherwise, tries to load from core integrations (TypeScript) first,
+ * then falls back to treating as a JSON file path.
  *
  * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
  * @returns The loaded IntegrationDSL

package/dist/cli/utils/integrations.js

@@ -1,35 +1,44 @@
 /**
  * Utilities for loading integrations from files.
  */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 /**
- * Load an integration DSL from a JSON file.
- * If the path ends with .json, treats it as a file path directly.
- * Otherwise, tries to load from core/integrations/ first, then falls back to treating as a file path.
+ * Load an integration DSL from a file or core integration.
+ * If the path ends with .json, treats it as a JSON file path directly.
+ * Otherwise, tries to load from core integrations (TypeScript) first,
+ * then falls back to treating as a JSON file path.
  *
  * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
  * @returns The loaded IntegrationDSL
  */
 export async function loadIntegrationDSL(nameOrPath) {
-    // If path ends with .json, treat it as a file path directly
+    // If path ends with .json, treat it as a JSON file path directly
     if (nameOrPath.endsWith(".json")) {
         const content = await readFile(nameOrPath, "utf-8");
         return JSON.parse(content);
     }
-    // Try loading from core/integrations/ first
-    // __dirname is src/cli/utils, so we go up to src/ then into core/integrations
-    const coreIntegrationsPath = join(__dirname, "../../core/integrations", `${nameOrPath}.json`);
+    // Try loading from core integrations (TypeScript) first
     try {
-        const content = await readFile(coreIntegrationsPath, "utf-8");
-        return JSON.parse(content);
+        const module = await import(__rewriteRelativeImportExtension(`../../core/integrations/${nameOrPath}.ts`));
+        // Core integrations export using the integration name directly (e.g., "supabase")
+        const integrationName = nameOrPath;
+        if (integrationName in module) {
+            return module[integrationName];
+        }
+        // If no matching export, fall through to JSON file loading
     }
     catch {
-        // Fallback to treating as file path
-        const content = await readFile(nameOrPath, "utf-8");
-        return JSON.parse(content);
+        // Module not found or not a core integration, fall through to JSON file loading
     }
+    // Fallback to treating as JSON file path
+    const content = await readFile(nameOrPath, "utf-8");
+    return JSON.parse(content);
 }

package/dist/core/catalog.model.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import { type PgDepend } from "./depend.ts";
 import { type Aggregate } from "./objects/aggregate/aggregate.model.ts";
 import type { TableLikeObject } from "./objects/base.model.ts";
@@ -89,5 +89,5 @@ export declare class Catalog {
     readonly currentUser: CatalogProps["currentUser"];
     constructor(props: CatalogProps);
 }
-export declare function extractCatalog(sql: Sql): Promise<Catalog>;
+export declare function extractCatalog(pool: Pool): Promise<Catalog>;
 export {};

package/dist/core/catalog.model.js

@@ -88,36 +88,36 @@ export class Catalog {
         this.currentUser = props.currentUser;
     }
 }
-export async function extractCatalog(sql) {
+export async function extractCatalog(pool) {
     const [aggregates, collations, compositeTypes, domains, enums, extensions, indexes, materializedViews, subscriptions, publications, procedures, rlsPolicies, roles, schemas, sequences, tables, triggers, eventTriggers, rules, ranges, views, foreignDataWrappers, servers, userMappings, foreignTables, depends, version, currentUser,] = await Promise.all([
-        extractAggregates(sql).then(listToRecord),
-        extractCollations(sql).then(listToRecord),
-        extractCompositeTypes(sql).then(listToRecord),
-        extractDomains(sql).then(listToRecord),
-        extractEnums(sql).then(listToRecord),
-        extractExtensions(sql).then(listToRecord),
-        extractIndexes(sql).then(listToRecord),
-        extractMaterializedViews(sql).then(listToRecord),
-        extractSubscriptions(sql).then(listToRecord),
-        extractPublications(sql).then(listToRecord),
-        extractProcedures(sql).then(listToRecord),
-        extractRlsPolicies(sql).then(listToRecord),
-        extractRoles(sql).then(listToRecord),
-        extractSchemas(sql).then(listToRecord),
-        extractSequences(sql).then(listToRecord),
-        extractTables(sql).then(listToRecord),
-        extractTriggers(sql).then(listToRecord),
-        extractEventTriggers(sql).then(listToRecord),
-        extractRules(sql).then(listToRecord),
-        extractRanges(sql).then(listToRecord),
-        extractViews(sql).then(listToRecord),
-        extractForeignDataWrappers(sql).then(listToRecord),
-        extractServers(sql).then(listToRecord),
-        extractUserMappings(sql).then(listToRecord),
-        extractForeignTables(sql).then(listToRecord),
-        extractDepends(sql),
-        extractVersion(sql),
-        extractCurrentUser(sql),
+        extractAggregates(pool).then(listToRecord),
+        extractCollations(pool).then(listToRecord),
+        extractCompositeTypes(pool).then(listToRecord),
+        extractDomains(pool).then(listToRecord),
+        extractEnums(pool).then(listToRecord),
+        extractExtensions(pool).then(listToRecord),
+        extractIndexes(pool).then(listToRecord),
+        extractMaterializedViews(pool).then(listToRecord),
+        extractSubscriptions(pool).then(listToRecord),
+        extractPublications(pool).then(listToRecord),
+        extractProcedures(pool).then(listToRecord),
+        extractRlsPolicies(pool).then(listToRecord),
+        extractRoles(pool).then(listToRecord),
+        extractSchemas(pool).then(listToRecord),
+        extractSequences(pool).then(listToRecord),
+        extractTables(pool).then(listToRecord),
+        extractTriggers(pool).then(listToRecord),
+        extractEventTriggers(pool).then(listToRecord),
+        extractRules(pool).then(listToRecord),
+        extractRanges(pool).then(listToRecord),
+        extractViews(pool).then(listToRecord),
+        extractForeignDataWrappers(pool).then(listToRecord),
+        extractServers(pool).then(listToRecord),
+        extractUserMappings(pool).then(listToRecord),
+        extractForeignTables(pool).then(listToRecord),
+        extractDepends(pool),
+        extractVersion(pool),
+        extractCurrentUser(pool),
     ]);
     const indexableObjects = {
         ...tables,

package/dist/core/context.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import type { Catalog } from "./catalog.model.ts";
 /**
  * Context for diff operations, containing both source and target catalogs.
@@ -7,5 +7,5 @@ export interface DiffContext {
     mainCatalog: Catalog;
     branchCatalog: Catalog;
 }
-export declare function extractVersion(sql: Sql): Promise<number>;
-export declare function extractCurrentUser(sql: Sql): Promise<string>;
+export declare function extractVersion(pool: Pool): Promise<number>;
+export declare function extractCurrentUser(pool: Pool): Promise<string>;

package/dist/core/context.js

@@ -1,12 +1,9 @@
-export async function extractVersion(sql) {
-    const [{ version }] = await sql `
-    select current_setting('server_version_num')::int as version;
-  `;
-    return version;
+import { sql } from "@ts-safeql/sql-tag";
+export async function extractVersion(pool) {
+    const { rows } = await pool.query(sql `select current_setting('server_version_num')::int as version`);
+    return rows[0].version;
 }
-export async function extractCurrentUser(sql) {
-    const [{ current_user }] = await sql `
-    select quote_ident(current_user) as current_user;
-  `;
-    return current_user;
+export async function extractCurrentUser(pool) {
+    const { rows } = await pool.query(sql `select quote_ident(current_user) as current_user`);
+    return rows[0].current_user;
 }

package/dist/core/depend.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 /**
  * Dependency type as defined in PostgreSQL's pg_depend.deptype.
  * n: normal
@@ -27,5 +27,5 @@ export interface PgDepend {
  * @param params - Object containing arrays of OIDs for filtering (user_oids, user_namespace_oids, etc.)
  * @returns Array of dependency objects with class names.
  */
-export declare function extractDepends(sql: Sql): Promise<PgDepend[]>;
+export declare function extractDepends(pool: Pool): Promise<PgDepend[]>;
 export {};

package/dist/core/depend.js

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 /**
  * Extract dependencies for privileges and memberships so that GRANT/REVOKE
  * operations are properly ordered with respect to their target objects/roles.
@@ -13,8 +14,8 @@
  *  - membership:<role>-><member> -> role:<role>
  *  - membership:<role>-><member> -> role:<member>
  */
-async function extractPrivilegeAndMembershipDepends(sql) {
-    const rows = await sql `
+async function extractPrivilegeAndMembershipDepends(pool) {
+    const { rows } = await pool.query(sql `
 with
   -- OBJECT PRIVILEGES (relations)
   extension_rel_oids as (
@@ -468,7 +469,7 @@ where dependent_stable_id <> referenced_stable_id
   and NOT (
     COALESCE(dep_schema, '') LIKE ANY (ARRAY['pg\\_%','information\\_schema'])
   )
-  `;
+  `);
     return rows;
 }
 /**
@@ -477,8 +478,8 @@ where dependent_stable_id <> referenced_stable_id
  * @param params - Object containing arrays of OIDs for filtering (user_oids, user_namespace_oids, etc.)
  * @returns Array of dependency objects with class names.
  */
-export async function extractDepends(sql) {
-    const dependsRows = await sql `
+export async function extractDepends(pool) {
+    const { rows: dependsRows } = await pool.query(sql `
   WITH ids AS (
     -- only the objects that actually show up in dependencies (both sides)
     SELECT DISTINCT classid, objid, objsubid FROM pg_depend WHERE deptype IN ('n','a')
@@ -1823,9 +1824,9 @@ export async function extractDepends(sql) {
       COALESCE(dep_schema, '') LIKE ANY (ARRAY['pg\\_%','information\\_schema'])
     )
   ORDER BY dependent_stable_id, referenced_stable_id;
-  `;
+  `);
     // Extract privilege and membership dependencies
-    const privilegeDepends = await extractPrivilegeAndMembershipDepends(sql);
+    const privilegeDepends = await extractPrivilegeAndMembershipDepends(pool);
     // Combine all dependency sources and remove duplicates
     const allDepends = new Set([...dependsRows, ...privilegeDepends]);
     return Array.from(allDepends).sort((a, b) => a.dependent_stable_id.localeCompare(b.dependent_stable_id) ||

package/dist/core/fingerprint.d.ts

@@ -13,11 +13,3 @@ export declare function buildPlanScopeFingerprint(catalog: Catalog, changes: Cha
  * Compute a fingerprint from a catalog and a set of stableIds.
  */
 export declare function hashStableIds(catalog: Catalog, stableIds: string[]): string;
-/**
- * Hash a string to hex SHA256.
- */
-export declare function sha256(input: string): string;
-/**
- * Collect the union of stableIds referenced by all changes.
- */
-export declare function collectStableIds(changes: Change[]): string[];

package/dist/core/fingerprint.js

@@ -31,13 +31,13 @@ export function hashStableIds(catalog, stableIds) {
 /**
  * Hash a string to hex SHA256.
  */
-export function sha256(input) {
+function sha256(input) {
     return crypto.createHash("sha256").update(input).digest("hex");
 }
 /**
  * Collect the union of stableIds referenced by all changes.
  */
-export function collectStableIds(changes) {
+function collectStableIds(changes) {
     const ids = new Set();
     for (const change of changes) {
         for (const id of getChangeStableIds(change)) {

package/dist/core/integrations/filter/dsl.d.ts

@@ -2,7 +2,7 @@
  * Filter DSL - A serializable domain-specific language for change filtering.
  */
 import type { Change } from "../../change.types.ts";
-import type { ChangeFilter } from "../../main.ts";
+import type { ChangeFilter } from "./filter.types.ts";
 /**
  * Core properties that all changes have.
  */

package/dist/core/integrations/filter/filter.types.d.ts

@@ -0,0 +1,2 @@
+import type { Change } from "../../change.types.ts";
+export type ChangeFilter = (change: Change) => boolean;

package/dist/core/integrations/filter/filter.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/integrations/integration.types.d.ts

@@ -1,4 +1,5 @@
-import type { ChangeFilter, ChangeSerializer } from "../main.ts";
+import type { ChangeFilter } from "./filter/filter.types.ts";
+import type { ChangeSerializer } from "./serialize/serialize.types.ts";
 export type Integration = {
     filter?: ChangeFilter;
     serialize?: ChangeSerializer;

package/dist/core/integrations/serialize/dsl.d.ts

@@ -3,8 +3,8 @@
  *
  * Reuses the filter pattern matching logic to determine when to apply serialization options.
  */
-import type { ChangeSerializer } from "../../main.ts";
 import { type FilterPattern } from "../filter/dsl.ts";
+import type { ChangeSerializer } from "./serialize.types.ts";
 /**
  * Serialization options that can be passed to change.serialize().
  */

package/dist/core/integrations/serialize/serialize.types.d.ts

@@ -0,0 +1,2 @@
+import type { Change } from "../../change.types.ts";
+export type ChangeSerializer = (change: Change) => string | undefined;

package/dist/core/integrations/serialize/serialize.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/integrations/supabase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Supabase integration - filtering and serialization rules for Supabase databases.
+ *
+ * This integration:
+ * - Filters out Supabase system schemas and roles
+ * - Includes user schemas and extensions
+ * - Skips authorization for schema creates owned by Supabase system roles
+ */
+import type { IntegrationDSL } from "./integration-dsl.ts";
+export declare const supabase: IntegrationDSL;

package/dist/core/integrations/supabase.js

@@ -0,0 +1,114 @@
+/**
+ * Supabase integration - filtering and serialization rules for Supabase databases.
+ *
+ * This integration:
+ * - Filters out Supabase system schemas and roles
+ * - Includes user schemas and extensions
+ * - Skips authorization for schema creates owned by Supabase system roles
+ */
+// Supabase system schemas that should be excluded
+const SUPABASE_SYSTEM_SCHEMAS = [
+    "_analytics",
+    "_realtime",
+    "_supavisor",
+    "auth",
+    "cron",
+    "extensions",
+    "graphql",
+    "graphql_public",
+    "information_schema",
+    "net",
+    "pgbouncer",
+    "pgmq",
+    "pgmq_public",
+    "pgsodium",
+    "pgsodium_masks",
+    "pgtle",
+    "realtime",
+    "storage",
+    "supabase_functions",
+    "supabase_migrations",
+    "vault",
+];
+// Supabase system roles that should be excluded
+const SUPABASE_SYSTEM_ROLES = [
+    "anon",
+    "authenticated",
+    "authenticator",
+    "dashboard_user",
+    "pgbouncer",
+    "pgsodium_keyholder",
+    "pgsodium_keyiduser",
+    "pgsodium_keymaker",
+    "pgtle_admin",
+    "service_role",
+    "supabase_admin",
+    "supabase_auth_admin",
+    "supabase_etl_admin",
+    "supabase_functions_admin",
+    "supabase_read_only_user",
+    "supabase_realtime_admin",
+    "supabase_replication_admin",
+    "supabase_storage_admin",
+];
+export const supabase = {
+    filter: {
+        or: [
+            {
+                and: [
+                    {
+                        type: "schema",
+                        operation: "create",
+                        scope: "object",
+                    },
+                    {
+                        not: {
+                            schema: [...SUPABASE_SYSTEM_SCHEMAS],
+                        },
+                    },
+                ],
+            },
+            {
+                type: "extension",
+                operation: "create",
+                scope: "object",
+            },
+            {
+                not: {
+                    or: [
+                        {
+                            schema: [...SUPABASE_SYSTEM_SCHEMAS],
+                        },
+                        {
+                            owner: [...SUPABASE_SYSTEM_ROLES],
+                        },
+                        {
+                            and: [
+                                {
+                                    type: "role",
+                                    scope: "membership",
+                                },
+                                {
+                                    member: [...SUPABASE_SYSTEM_ROLES],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        ],
+    },
+    serialize: [
+        {
+            when: {
+                type: "schema",
+                operation: "create",
+                scope: "object",
+                owner: [...SUPABASE_SYSTEM_ROLES],
+            },
+            options: {
+                skipAuthorization: true,
+            },
+        },
+    ],
+};

package/dist/core/objects/aggregate/aggregate.model.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -16,9 +16,9 @@ declare const aggregatePropsSchema: z.ZodObject<{
     return_type: z.ZodString;
     return_type_schema: z.ZodNullable<z.ZodString>;
     parallel_safety: z.ZodEnum<{
+        r: "r";
         u: "u";
         s: "s";
-        r: "r";
     }>;
     is_strict: z.ZodBoolean;
     transition_function: z.ZodString;
@@ -28,8 +28,8 @@ declare const aggregatePropsSchema: z.ZodObject<{
     final_function: z.ZodNullable<z.ZodString>;
     final_function_extra_args: z.ZodBoolean;
     final_function_modify: z.ZodNullable<z.ZodEnum<{
-        s: "s";
         r: "r";
+        s: "s";
         w: "w";
     }>>;
     combine_function: z.ZodNullable<z.ZodString>;
@@ -44,8 +44,8 @@ declare const aggregatePropsSchema: z.ZodObject<{
     moving_final_function: z.ZodNullable<z.ZodString>;
     moving_final_function_extra_args: z.ZodBoolean;
     moving_final_function_modify: z.ZodNullable<z.ZodEnum<{
-        s: "s";
         r: "r";
+        s: "s";
         w: "w";
     }>>;
     moving_initial_condition: z.ZodNullable<z.ZodString>;
@@ -56,8 +56,8 @@ declare const aggregatePropsSchema: z.ZodObject<{
     argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     all_argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     argument_modes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        i: "i";
         o: "o";
+        i: "i";
         b: "b";
         v: "v";
         t: "t";
@@ -129,7 +129,7 @@ export declare class Aggregate extends BasePgModel {
         num_direct_args: number;
         return_type: string;
         return_type_schema: string | null;
-        parallel_safety: "u" | "s" | "r";
+        parallel_safety: "r" | "u" | "s";
         is_strict: boolean;
         transition_function: string;
         state_data_type: string;
@@ -137,7 +137,7 @@ export declare class Aggregate extends BasePgModel {
         state_data_space: number;
         final_function: string | null;
         final_function_extra_args: boolean;
-        final_function_modify: "s" | "r" | "w" | null;
+        final_function_modify: "r" | "s" | "w" | null;
         combine_function: string | null;
         serial_function: string | null;
         deserial_function: string | null;
@@ -149,7 +149,7 @@ export declare class Aggregate extends BasePgModel {
         moving_state_data_space: number | null;
         moving_final_function: string | null;
         moving_final_function_extra_args: boolean;
-        moving_final_function_modify: "s" | "r" | "w" | null;
+        moving_final_function_modify: "r" | "s" | "w" | null;
         moving_initial_condition: string | null;
         sort_operator: string | null;
         argument_count: number;
@@ -157,7 +157,7 @@ export declare class Aggregate extends BasePgModel {
         argument_names: string[] | null;
         argument_types: string[] | null;
         all_argument_types: string[] | null;
-        argument_modes: ("i" | "o" | "b" | "v" | "t")[] | null;
+        argument_modes: ("o" | "i" | "b" | "v" | "t")[] | null;
         argument_defaults: string | null;
         identity_arguments: string;
         owner: string;
@@ -170,5 +170,5 @@ export declare class Aggregate extends BasePgModel {
         }[];
     };
 }
-export declare function extractAggregates(sql: Sql): Promise<Aggregate[]>;
+export declare function extractAggregates(pool: Pool): Promise<Aggregate[]>;
 export {};

package/dist/core/objects/aggregate/aggregate.model.js

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
@@ -208,10 +209,8 @@ export class Aggregate extends BasePgModel {
         };
     }
 }
-export async function extractAggregates(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const aggregateRows = await sql `
+export async function extractAggregates(pool) {
+    const { rows: aggregateRows } = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -289,9 +288,8 @@ where
   and not p.pronamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
   and e.objid is null
 order by
-  1, 2, 3;
-    `;
-        const validatedRows = aggregateRows.map((row) => aggregatePropsSchema.parse(row));
-        return validatedRows.map((row) => new Aggregate(row));
-    });
+  1, 2, 3
+  `);
+    const validatedRows = aggregateRows.map((row) => aggregatePropsSchema.parse(row));
+    return validatedRows.map((row) => new Aggregate(row));
 }

package/dist/core/objects/collation/collation.model.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 /**
@@ -63,5 +63,5 @@ export declare class Collation extends BasePgModel {
         comment: string | null;
     };
 }
-export declare function extractCollations(sql: Sql): Promise<Collation[]>;
+export declare function extractCollations(pool: Pool): Promise<Collation[]>;
 export {};