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

package/dist/core/objects/foreign-data-wrapper/server/changes/server.alter.js

@@ -0,0 +1,84 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { AlterServerChange } from "./server.base.js";
+/**
+ * ALTER SERVER ... OWNER TO ...
+ */
+export class AlterServerChangeOwner extends AlterServerChange {
+    server;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.server.stableId, stableId.role(this.owner)];
+    }
+    serialize() {
+        return ["ALTER SERVER", this.server.name, "OWNER TO", this.owner].join(" ");
+    }
+}
+/**
+ * ALTER SERVER ... VERSION ...
+ */
+export class AlterServerSetVersion extends AlterServerChange {
+    server;
+    version;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.version = props.version;
+    }
+    get requires() {
+        return [this.server.stableId];
+    }
+    serialize() {
+        if (this.version === null) {
+            // PostgreSQL doesn't support removing version, but we'll handle it
+            return ["ALTER SERVER", this.server.name, "VERSION", "''"].join(" ");
+        }
+        return [
+            "ALTER SERVER",
+            this.server.name,
+            "VERSION",
+            quoteLiteral(this.version),
+        ].join(" ");
+    }
+}
+/**
+ * ALTER SERVER ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterServerSetOptions extends AlterServerChange {
+    server;
+    options;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.options = props.options;
+    }
+    get requires() {
+        return [this.server.stableId];
+    }
+    serialize() {
+        const optionParts = [];
+        for (const opt of this.options) {
+            if (opt.action === "DROP") {
+                optionParts.push(`DROP ${opt.option}`);
+            }
+            else {
+                const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+                optionParts.push(`${opt.action} ${opt.option} ${value}`);
+            }
+        }
+        return [
+            "ALTER SERVER",
+            this.server.name,
+            "OPTIONS",
+            `(${optionParts.join(", ")})`,
+        ].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { Server } from "../server.model.ts";
+declare abstract class BaseServerChange extends BaseChange {
+    abstract readonly server: Server;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "server";
+}
+export declare abstract class CreateServerChange extends BaseServerChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterServerChange extends BaseServerChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropServerChange extends BaseServerChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/foreign-data-wrapper/server/changes/server.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../../base.change.js";
+class BaseServerChange extends BaseChange {
+    objectType = "server";
+}
+export class CreateServerChange extends BaseServerChange {
+    operation = "create";
+}
+export class AlterServerChange extends BaseServerChange {
+    operation = "alter";
+}
+export class DropServerChange extends BaseServerChange {
+    operation = "drop";
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.comment.d.ts

@@ -0,0 +1,26 @@
+import type { Server } from "../server.model.ts";
+import { CreateServerChange, DropServerChange } from "./server.base.ts";
+/**
+ * Create/drop comments on servers.
+ */
+export type CommentServer = CreateCommentOnServer | DropCommentOnServer;
+export declare class CreateCommentOnServer extends CreateServerChange {
+    readonly server: Server;
+    readonly scope: "comment";
+    constructor(props: {
+        server: Server;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `server:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnServer extends DropServerChange {
+    readonly server: Server;
+    readonly scope: "comment";
+    constructor(props: {
+        server: Server;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `server:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.comment.js

@@ -0,0 +1,43 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateServerChange, DropServerChange } from "./server.base.js";
+export class CreateCommentOnServer extends CreateServerChange {
+    server;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.server = props.server;
+    }
+    get creates() {
+        return [stableId.comment(this.server.stableId)];
+    }
+    get requires() {
+        return [this.server.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON SERVER",
+            this.server.name,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+            quoteLiteral(this.server.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnServer extends DropServerChange {
+    server;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.server = props.server;
+    }
+    get drops() {
+        return [stableId.comment(this.server.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.server.stableId), this.server.stableId];
+    }
+    serialize() {
+        return ["COMMENT ON SERVER", this.server.name, "IS NULL"].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.create.d.ts

@@ -0,0 +1,24 @@
+import type { Server } from "../server.model.ts";
+import { CreateServerChange } from "./server.base.ts";
+/**
+ * Create a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createserver.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE SERVER [ IF NOT EXISTS ] server_name [ TYPE 'server_type' ] [ VERSION 'server_version' ]
+ *     FOREIGN DATA WRAPPER fdw_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export declare class CreateServer extends CreateServerChange {
+    readonly server: Server;
+    readonly scope: "object";
+    constructor(props: {
+        server: Server;
+    });
+    get creates(): `server:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.create.js

@@ -0,0 +1,62 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateServerChange } from "./server.base.js";
+/**
+ * Create a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createserver.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE SERVER [ IF NOT EXISTS ] server_name [ TYPE 'server_type' ] [ VERSION 'server_version' ]
+ *     FOREIGN DATA WRAPPER fdw_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateServer extends CreateServerChange {
+    server;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.server = props.server;
+    }
+    get creates() {
+        return [this.server.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Foreign Data Wrapper dependency
+        dependencies.add(stableId.foreignDataWrapper(this.server.foreign_data_wrapper));
+        // Owner dependency
+        dependencies.add(stableId.role(this.server.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE SERVER"];
+        // Add server name
+        parts.push(this.server.name);
+        // Add TYPE clause
+        if (this.server.type) {
+            parts.push("TYPE", quoteLiteral(this.server.type));
+        }
+        // Add VERSION clause
+        if (this.server.version) {
+            parts.push("VERSION", quoteLiteral(this.server.version));
+        }
+        // Add FOREIGN DATA WRAPPER clause
+        parts.push("FOREIGN DATA WRAPPER", this.server.foreign_data_wrapper);
+        // Add OPTIONS clause
+        if (this.server.options && this.server.options.length > 0) {
+            const optionPairs = [];
+            for (let i = 0; i < this.server.options.length; i += 2) {
+                if (i + 1 < this.server.options.length) {
+                    optionPairs.push(`${this.server.options[i]} ${quoteLiteral(this.server.options[i + 1])}`);
+                }
+            }
+            if (optionPairs.length > 0) {
+                parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+            }
+        }
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.drop.d.ts

@@ -0,0 +1,22 @@
+import type { Server } from "../server.model.ts";
+import { DropServerChange } from "./server.base.ts";
+/**
+ * Drop a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropserver.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP SERVER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropServer extends DropServerChange {
+    readonly server: Server;
+    readonly scope: "object";
+    constructor(props: {
+        server: Server;
+    });
+    get drops(): `server:${string}`[];
+    get requires(): `server:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.drop.js

@@ -0,0 +1,28 @@
+import { DropServerChange } from "./server.base.js";
+/**
+ * Drop a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropserver.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP SERVER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropServer extends DropServerChange {
+    server;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.server = props.server;
+    }
+    get drops() {
+        return [this.server.stableId];
+    }
+    get requires() {
+        return [this.server.stableId];
+    }
+    serialize() {
+        return ["DROP SERVER", this.server.name].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.privilege.d.ts

@@ -0,0 +1,97 @@
+import type { Server } from "../server.model.ts";
+import { AlterServerChange } from "./server.base.ts";
+export type ServerPrivilege = GrantServerPrivileges | RevokeServerPrivileges | RevokeGrantOptionServerPrivileges;
+/**
+ * Grant privileges on a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON SERVER server_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantServerPrivileges extends AlterServerChange {
+    readonly server: Server;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        server: Server;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `server:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON SERVER server_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeServerPrivileges extends AlterServerChange {
+    readonly server: Server;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        server: Server;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `server:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a server.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export declare class RevokeGrantOptionServerPrivileges extends AlterServerChange {
+    readonly server: Server;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        server: Server;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `server:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.privilege.js

@@ -0,0 +1,123 @@
+import { formatObjectPrivilegeList } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterServerChange } from "./server.base.js";
+/**
+ * Grant privileges on a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON SERVER server_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantServerPrivileges extends AlterServerChange {
+    server;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.server.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.server.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantServerPrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SERVER", list, this.version);
+        return `GRANT ${privSql} ON SERVER ${this.server.name} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON SERVER server_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeServerPrivileges extends AlterServerChange {
+    server;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        return [stableId.acl(this.server.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.server.stableId, this.grantee),
+            this.server.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SERVER", list, this.version);
+        return `REVOKE ${privSql} ON SERVER ${this.server.name} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a server.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionServerPrivileges extends AlterServerChange {
+    server;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.server = props.server;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.server.stableId, this.grantee),
+            this.server.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const privSql = formatObjectPrivilegeList("SERVER", this.privilegeNames, this.version);
+        return `REVOKE GRANT OPTION FOR ${privSql} ON SERVER ${this.server.name} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/foreign-data-wrapper/server/changes/server.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterServer } from "./server.alter.ts";
+import type { CommentServer } from "./server.comment.ts";
+import type { CreateServer } from "./server.create.ts";
+import type { DropServer } from "./server.drop.ts";
+import type { ServerPrivilege } from "./server.privilege.ts";
+export type ServerChange = AlterServer | CommentServer | CreateServer | DropServer | ServerPrivilege;

package/dist/core/objects/foreign-data-wrapper/server/changes/server.types.js

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

package/dist/core/objects/foreign-data-wrapper/server/server.diff.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import type { Role } from "../../role/role.model.ts";
+import type { ServerChange } from "./changes/server.types.ts";
+import type { Server } from "./server.model.ts";
+/**
+ * Diff two sets of servers from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The servers in the main catalog.
+ * @param branch - The servers in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffServers(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, Server>, branch: Record<string, Server>): ServerChange[];