@supabase/pg-delta 0.0.0 → 1.0.0-alpha.1

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

@@ -0,0 +1,93 @@
+import type { Sql } from "postgres";
+import { type PgDepend } from "./depend.ts";
+import { type Aggregate } from "./objects/aggregate/aggregate.model.ts";
+import type { TableLikeObject } from "./objects/base.model.ts";
+import { type Collation } from "./objects/collation/collation.model.ts";
+import type { Domain } from "./objects/domain/domain.model.ts";
+import { type EventTrigger } from "./objects/event-trigger/event-trigger.model.ts";
+import { type Extension } from "./objects/extension/extension.model.ts";
+import { type ForeignDataWrapper } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.ts";
+import { type ForeignTable } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts";
+import { Server } from "./objects/foreign-data-wrapper/server/server.model.ts";
+import { UserMapping } from "./objects/foreign-data-wrapper/user-mapping/user-mapping.model.ts";
+import { type Index } from "./objects/index/index.model.ts";
+import { type MaterializedView } from "./objects/materialized-view/materialized-view.model.ts";
+import { type Procedure } from "./objects/procedure/procedure.model.ts";
+import { type Publication } from "./objects/publication/publication.model.ts";
+import { type RlsPolicy } from "./objects/rls-policy/rls-policy.model.ts";
+import { type Role } from "./objects/role/role.model.ts";
+import { type Rule } from "./objects/rule/rule.model.ts";
+import { type Schema } from "./objects/schema/schema.model.ts";
+import { type Sequence } from "./objects/sequence/sequence.model.ts";
+import { Subscription } from "./objects/subscription/subscription.model.ts";
+import { type Table } from "./objects/table/table.model.ts";
+import { type Trigger } from "./objects/trigger/trigger.model.ts";
+import { type CompositeType } from "./objects/type/composite-type/composite-type.model.ts";
+import { type Enum } from "./objects/type/enum/enum.model.ts";
+import { type Range } from "./objects/type/range/range.model.ts";
+import { type View } from "./objects/view/view.model.ts";
+interface CatalogProps {
+    aggregates: Record<string, Aggregate>;
+    collations: Record<string, Collation>;
+    compositeTypes: Record<string, CompositeType>;
+    domains: Record<string, Domain>;
+    enums: Record<string, Enum>;
+    extensions: Record<string, Extension>;
+    procedures: Record<string, Procedure>;
+    indexes: Record<string, Index>;
+    materializedViews: Record<string, MaterializedView>;
+    subscriptions: Record<string, Subscription>;
+    publications: Record<string, Publication>;
+    rlsPolicies: Record<string, RlsPolicy>;
+    roles: Record<string, Role>;
+    schemas: Record<string, Schema>;
+    sequences: Record<string, Sequence>;
+    tables: Record<string, Table>;
+    triggers: Record<string, Trigger>;
+    eventTriggers: Record<string, EventTrigger>;
+    rules: Record<string, Rule>;
+    ranges: Record<string, Range>;
+    views: Record<string, View>;
+    foreignDataWrappers: Record<string, ForeignDataWrapper>;
+    servers: Record<string, Server>;
+    userMappings: Record<string, UserMapping>;
+    foreignTables: Record<string, ForeignTable>;
+    depends: PgDepend[];
+    indexableObjects: Record<string, TableLikeObject>;
+    version: number;
+    currentUser: string;
+}
+export declare class Catalog {
+    readonly aggregates: CatalogProps["aggregates"];
+    readonly collations: CatalogProps["collations"];
+    readonly compositeTypes: CatalogProps["compositeTypes"];
+    readonly domains: CatalogProps["domains"];
+    readonly enums: CatalogProps["enums"];
+    readonly extensions: CatalogProps["extensions"];
+    readonly procedures: CatalogProps["procedures"];
+    readonly indexes: CatalogProps["indexes"];
+    readonly materializedViews: CatalogProps["materializedViews"];
+    readonly subscriptions: CatalogProps["subscriptions"];
+    readonly publications: CatalogProps["publications"];
+    readonly rlsPolicies: CatalogProps["rlsPolicies"];
+    readonly roles: CatalogProps["roles"];
+    readonly schemas: CatalogProps["schemas"];
+    readonly sequences: CatalogProps["sequences"];
+    readonly tables: CatalogProps["tables"];
+    readonly triggers: CatalogProps["triggers"];
+    readonly eventTriggers: CatalogProps["eventTriggers"];
+    readonly rules: CatalogProps["rules"];
+    readonly ranges: CatalogProps["ranges"];
+    readonly views: CatalogProps["views"];
+    readonly foreignDataWrappers: CatalogProps["foreignDataWrappers"];
+    readonly servers: CatalogProps["servers"];
+    readonly userMappings: CatalogProps["userMappings"];
+    readonly foreignTables: CatalogProps["foreignTables"];
+    readonly depends: CatalogProps["depends"];
+    readonly indexableObjects: CatalogProps["indexableObjects"];
+    readonly version: CatalogProps["version"];
+    readonly currentUser: CatalogProps["currentUser"];
+    constructor(props: CatalogProps);
+}
+export declare function extractCatalog(sql: Sql): Promise<Catalog>;
+export {};

package/dist/core/catalog.model.js

@@ -0,0 +1,254 @@
+import { extractCurrentUser, extractVersion } from "./context.js";
+import { extractDepends } from "./depend.js";
+import { extractAggregates, } from "./objects/aggregate/aggregate.model.js";
+import { extractCollations, } from "./objects/collation/collation.model.js";
+import { extractDomains } from "./objects/domain/domain.model.js";
+import { extractEventTriggers, } from "./objects/event-trigger/event-trigger.model.js";
+import { extractExtensions, } from "./objects/extension/extension.model.js";
+import { extractForeignDataWrappers, } from "./objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.js";
+import { extractForeignTables, } from "./objects/foreign-data-wrapper/foreign-table/foreign-table.model.js";
+import { extractServers, Server, } from "./objects/foreign-data-wrapper/server/server.model.js";
+import { extractUserMappings, UserMapping, } from "./objects/foreign-data-wrapper/user-mapping/user-mapping.model.js";
+import { extractIndexes } from "./objects/index/index.model.js";
+import { extractMaterializedViews, } from "./objects/materialized-view/materialized-view.model.js";
+import { extractProcedures, } from "./objects/procedure/procedure.model.js";
+import { extractPublications, } from "./objects/publication/publication.model.js";
+import { extractRlsPolicies, } from "./objects/rls-policy/rls-policy.model.js";
+import { extractRoles } from "./objects/role/role.model.js";
+import { extractRules } from "./objects/rule/rule.model.js";
+import { extractSchemas } from "./objects/schema/schema.model.js";
+import { extractSequences, } from "./objects/sequence/sequence.model.js";
+import { extractSubscriptions, Subscription, } from "./objects/subscription/subscription.model.js";
+import { extractTables } from "./objects/table/table.model.js";
+import { extractTriggers, } from "./objects/trigger/trigger.model.js";
+import { extractCompositeTypes, } from "./objects/type/composite-type/composite-type.model.js";
+import { extractEnums } from "./objects/type/enum/enum.model.js";
+import { extractRanges } from "./objects/type/range/range.model.js";
+import { extractViews } from "./objects/view/view.model.js";
+const SUBSCRIPTION_CONNINFO_PLACEHOLDER = "host=__CONN_HOST__ port=__CONN_PORT__ dbname=__CONN_DBNAME__ user=__CONN_USER__ password=__CONN_PASSWORD__";
+export class Catalog {
+    aggregates;
+    collations;
+    compositeTypes;
+    domains;
+    enums;
+    extensions;
+    procedures;
+    indexes;
+    materializedViews;
+    subscriptions;
+    publications;
+    rlsPolicies;
+    roles;
+    schemas;
+    sequences;
+    tables;
+    triggers;
+    eventTriggers;
+    rules;
+    ranges;
+    views;
+    foreignDataWrappers;
+    servers;
+    userMappings;
+    foreignTables;
+    depends;
+    indexableObjects;
+    version;
+    currentUser;
+    constructor(props) {
+        this.aggregates = props.aggregates;
+        this.collations = props.collations;
+        this.compositeTypes = props.compositeTypes;
+        this.domains = props.domains;
+        this.enums = props.enums;
+        this.extensions = props.extensions;
+        this.procedures = props.procedures;
+        this.indexes = props.indexes;
+        this.materializedViews = props.materializedViews;
+        this.subscriptions = props.subscriptions;
+        this.publications = props.publications;
+        this.rlsPolicies = props.rlsPolicies;
+        this.roles = props.roles;
+        this.schemas = props.schemas;
+        this.sequences = props.sequences;
+        this.tables = props.tables;
+        this.triggers = props.triggers;
+        this.eventTriggers = props.eventTriggers;
+        this.rules = props.rules;
+        this.ranges = props.ranges;
+        this.views = props.views;
+        this.foreignDataWrappers = props.foreignDataWrappers;
+        this.servers = props.servers;
+        this.userMappings = props.userMappings;
+        this.foreignTables = props.foreignTables;
+        this.depends = props.depends;
+        this.indexableObjects = props.indexableObjects;
+        this.version = props.version;
+        this.currentUser = props.currentUser;
+    }
+}
+export async function extractCatalog(sql) {
+    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),
+    ]);
+    const indexableObjects = {
+        ...tables,
+        ...materializedViews,
+    };
+    const catalog = new Catalog({
+        aggregates,
+        collations,
+        compositeTypes,
+        domains,
+        enums,
+        extensions,
+        procedures,
+        indexes,
+        materializedViews,
+        subscriptions,
+        publications,
+        rlsPolicies,
+        roles,
+        schemas,
+        sequences,
+        tables,
+        triggers,
+        eventTriggers,
+        rules,
+        ranges,
+        views,
+        foreignDataWrappers,
+        servers,
+        userMappings,
+        foreignTables,
+        depends,
+        indexableObjects,
+        version,
+        currentUser,
+    });
+    return normalizeCatalog(catalog);
+}
+function listToRecord(list) {
+    return Object.fromEntries(list.map((item) => [item.stableId, item]));
+}
+function normalizeCatalog(catalog) {
+    const servers = mapRecord(catalog.servers, (server) => {
+        const maskedOptions = maskOptions(server.options);
+        return new Server({
+            name: server.name,
+            owner: server.owner,
+            foreign_data_wrapper: server.foreign_data_wrapper,
+            type: server.type,
+            version: server.version,
+            options: maskedOptions,
+            comment: server.comment,
+            privileges: server.privileges,
+        });
+    });
+    const userMappings = mapRecord(catalog.userMappings, (mapping) => {
+        const maskedOptions = maskOptions(mapping.options);
+        return new UserMapping({
+            user: mapping.user,
+            server: mapping.server,
+            options: maskedOptions,
+        });
+    });
+    const subscriptions = mapRecord(catalog.subscriptions, (subscription) => {
+        return new Subscription({
+            name: subscription.name,
+            raw_name: subscription.raw_name,
+            owner: subscription.owner,
+            comment: subscription.comment,
+            enabled: subscription.enabled,
+            binary: subscription.binary,
+            streaming: subscription.streaming,
+            two_phase: subscription.two_phase,
+            disable_on_error: subscription.disable_on_error,
+            password_required: subscription.password_required,
+            run_as_owner: subscription.run_as_owner,
+            failover: subscription.failover,
+            conninfo: SUBSCRIPTION_CONNINFO_PLACEHOLDER,
+            slot_name: subscription.slot_name,
+            slot_is_none: subscription.slot_is_none,
+            replication_slot_created: subscription.replication_slot_created,
+            synchronous_commit: subscription.synchronous_commit,
+            publications: subscription.publications,
+            origin: subscription.origin,
+        });
+    });
+    return new Catalog({
+        aggregates: catalog.aggregates,
+        collations: catalog.collations,
+        compositeTypes: catalog.compositeTypes,
+        domains: catalog.domains,
+        enums: catalog.enums,
+        extensions: catalog.extensions,
+        procedures: catalog.procedures,
+        indexes: catalog.indexes,
+        materializedViews: catalog.materializedViews,
+        subscriptions,
+        publications: catalog.publications,
+        rlsPolicies: catalog.rlsPolicies,
+        roles: catalog.roles,
+        schemas: catalog.schemas,
+        sequences: catalog.sequences,
+        tables: catalog.tables,
+        triggers: catalog.triggers,
+        eventTriggers: catalog.eventTriggers,
+        rules: catalog.rules,
+        ranges: catalog.ranges,
+        views: catalog.views,
+        foreignDataWrappers: catalog.foreignDataWrappers,
+        servers,
+        userMappings,
+        foreignTables: catalog.foreignTables,
+        depends: catalog.depends,
+        indexableObjects: catalog.indexableObjects,
+        version: catalog.version,
+        currentUser: catalog.currentUser,
+    });
+}
+function maskOptions(options) {
+    if (!options || options.length === 0)
+        return options;
+    const masked = [];
+    for (let i = 0; i < options.length; i += 2) {
+        const key = options[i];
+        const value = options[i + 1];
+        if (key === undefined || value === undefined)
+            continue;
+        masked.push(key, `__OPTION_${key.toUpperCase()}__`);
+    }
+    return masked.length > 0 ? masked : null;
+}
+function mapRecord(record, mapper) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
+}

package/dist/core/change.types.d.ts

@@ -0,0 +1,22 @@
+import type { AggregateChange } from "./objects/aggregate/changes/aggregate.types.ts";
+import type { CollationChange } from "./objects/collation/changes/collation.types.ts";
+import type { DomainChange } from "./objects/domain/changes/domain.types.ts";
+import type { EventTriggerChange } from "./objects/event-trigger/changes/event-trigger.types.ts";
+import type { ExtensionChange } from "./objects/extension/changes/extension.types.ts";
+import type { ForeignDataWrapperChange } from "./objects/foreign-data-wrapper/foreign-data-wrapper.types.ts";
+import type { IndexChange } from "./objects/index/changes/index.types.ts";
+import type { LanguageChange } from "./objects/language/changes/language.types.ts";
+import type { MaterializedViewChange } from "./objects/materialized-view/changes/materialized-view.types.ts";
+import type { ProcedureChange } from "./objects/procedure/changes/procedure.types.ts";
+import type { PublicationChange } from "./objects/publication/changes/publication.types.ts";
+import type { RlsPolicyChange } from "./objects/rls-policy/changes/rls-policy.types.ts";
+import type { RoleChange } from "./objects/role/changes/role.types.ts";
+import type { RuleChange } from "./objects/rule/changes/rule.types.ts";
+import type { SchemaChange } from "./objects/schema/changes/schema.types.ts";
+import type { SequenceChange } from "./objects/sequence/changes/sequence.types.ts";
+import type { SubscriptionChange } from "./objects/subscription/changes/subscription.types.ts";
+import type { TableChange } from "./objects/table/changes/table.types.ts";
+import type { TriggerChange } from "./objects/trigger/changes/trigger.types.ts";
+import type { TypeChange } from "./objects/type/type.types.ts";
+import type { ViewChange } from "./objects/view/changes/view.types.ts";
+export type Change = AggregateChange | CollationChange | DomainChange | ExtensionChange | IndexChange | LanguageChange | MaterializedViewChange | SubscriptionChange | PublicationChange | ProcedureChange | RlsPolicyChange | RoleChange | SchemaChange | SequenceChange | TableChange | TriggerChange | EventTriggerChange | RuleChange | TypeChange | ViewChange | ForeignDataWrapperChange;

package/dist/core/change.types.js

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

package/dist/core/context.d.ts

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

package/dist/core/context.js

@@ -0,0 +1,12 @@
+export async function extractVersion(sql) {
+    const [{ version }] = await sql `
+    select current_setting('server_version_num')::int as version;
+  `;
+    return version;
+}
+export async function extractCurrentUser(sql) {
+    const [{ current_user }] = await sql `
+    select quote_ident(current_user) as current_user;
+  `;
+    return current_user;
+}

package/dist/core/depend.d.ts

@@ -0,0 +1,31 @@
+import type { Sql } from "postgres";
+/**
+ * Dependency type as defined in PostgreSQL's pg_depend.deptype.
+ * n: normal
+ * a: auto
+ * i: internal
+ */
+type PgDependType = "n" | "a" | "i";
+export interface PgDepend {
+    dependent_stable_id: string;
+    referenced_stable_id: string;
+    /**
+     * Dependency type as defined in PostgreSQL's pg_depend.deptype.
+     *
+     * - "n" (normal): Ordinary dependency — if the referenced object is dropped, the dependent object is also dropped automatically.
+     *   Example: a table column depends on its table.
+     * - "a" (auto): Automatically created dependency — the dependent object was created as a result of creating the referenced object,
+     *   and should be dropped automatically when the referenced object is dropped, but not otherwise treated as a strong link.
+     * - "i" (internal): Internal dependency — the dependent object is a low-level part of the referenced object and cannot be dropped
+     *   without dropping the whole referenced object. Example: a table's toast table or an index that's part of a unique constraint.
+     */
+    deptype: PgDependType;
+}
+/**
+ * Extract all dependencies from pg_depend, joining with pg_class for class names and applying user object filters.
+ * @param sql - The SQL client.
+ * @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 {};