@prostgles/prostgles 2.3.6-dev.1786615880 → 2.3.6-dev.1786992729

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.d.ts

@@ -0,0 +1,453 @@
+export declare const backupServerFunctions: {
+    readonly backupConnections: {
+        input?: {
+            connectionNames: {
+                optional: true;
+                type: "string[]";
+            };
+            allActive: {
+                optional: true;
+                type: "boolean";
+            };
+            name: "string";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            connectionNames: {
+                optional: true;
+                type: "string[]";
+            };
+            allActive: {
+                optional: true;
+                type: "boolean";
+            };
+            name: "string";
+        }>, context: import("prostgles-server").UnrestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+    } & {
+        unrestrictedDbAccess: true;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly restoreConnections: {
+        input?: {
+            backupName: "string";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            backupName: "string";
+        }>, context: import("prostgles-server").UnrestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<number>;
+    } & {
+        unrestrictedDbAccess: true;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly pgDump: {
+        input?: {
+            conId: "string";
+            credId: {
+                oneOf: ("number" | {
+                    enum: null[];
+                })[];
+            };
+            opts: {
+                type: {
+                    name: {
+                        type: "string";
+                        optional: true;
+                    };
+                    initiator: {
+                        type: "string";
+                        optional: true;
+                    };
+                    options: {
+                        readonly oneOfType: readonly [{
+                            readonly command: {
+                                readonly enum: readonly ["pg_dumpall"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly globalsOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly rolesOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }, {
+                            readonly command: {
+                                readonly enum: readonly ["pg_dump"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly compressionLevel: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                };
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            conId: "string";
+            credId: {
+                oneOf: ("number" | {
+                    enum: null[];
+                })[];
+            };
+            opts: {
+                type: {
+                    name: {
+                        type: "string";
+                        optional: true;
+                    };
+                    initiator: {
+                        type: "string";
+                        optional: true;
+                    };
+                    options: {
+                        readonly oneOfType: readonly [{
+                            readonly command: {
+                                readonly enum: readonly ["pg_dumpall"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly globalsOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly rolesOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }, {
+                            readonly command: {
+                                readonly enum: readonly ["pg_dump"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly encoding: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly compressionLevel: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly schemaOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                };
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly pgRestore: {
+        input?: {
+            bkpId: "string";
+            connId: {
+                type: "string";
+                optional: true;
+            };
+            opts: "any";
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            bkpId: "string";
+            connId: {
+                type: "string";
+                optional: true;
+            };
+            opts: "any";
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<void>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly bkpDelete: {
+        input?: {
+            bkpId: "string";
+            force: {
+                type: "boolean";
+                optional: true;
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            bkpId: "string";
+            force: {
+                type: "boolean";
+                optional: true;
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+    readonly streamBackupFile: {
+        input?: {
+            data: {
+                oneOfType: readonly [{
+                    readonly type: {
+                        readonly enum: readonly ["start"];
+                    };
+                    readonly fileName: "string";
+                    readonly connectionId: "string";
+                    readonly sizeBytes: "integer";
+                    readonly restoreOptions: {
+                        readonly type: {
+                            readonly command: {
+                                readonly enum: readonly ["pg_restore", "psql"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly singleTransaction: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly newDbName: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["chunk"];
+                    };
+                    readonly streamId: "string";
+                    readonly chunk: "Blob";
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["end"];
+                    };
+                    readonly streamId: "string";
+                }];
+            };
+        } | undefined;
+        description?: string;
+        run: (args: import("prostgles-types").JSONB.GetObjectType<{
+            data: {
+                oneOfType: readonly [{
+                    readonly type: {
+                        readonly enum: readonly ["start"];
+                    };
+                    readonly fileName: "string";
+                    readonly connectionId: "string";
+                    readonly sizeBytes: "integer";
+                    readonly restoreOptions: {
+                        readonly type: {
+                            readonly command: {
+                                readonly enum: readonly ["pg_restore", "psql"];
+                            };
+                            readonly format: {
+                                readonly enum: readonly ["p", "t", "c"];
+                            };
+                            readonly clean: {
+                                readonly type: "boolean";
+                            };
+                            readonly singleTransaction: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly excludeSchema: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly newDbName: {
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly create: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly dataOnly: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly noOwner: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly numberOfJobs: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                            };
+                            readonly ifExists: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly keepLogs: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["chunk"];
+                    };
+                    readonly streamId: "string";
+                    readonly chunk: "Blob";
+                }, {
+                    readonly type: {
+                        readonly enum: readonly ["end"];
+                    };
+                    readonly streamId: "string";
+                }];
+            };
+        }>, context: import("prostgles-server").RestrictedFunctionContext<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>) => import("prostgles-types").MaybePromise<string | undefined>;
+    } & {
+        unrestrictedDbAccess?: undefined;
+    } & import("prostgles-server").ServerFunctionContextMarker<import("../../../../common/DBGeneratedSchema").DBGeneratedSchema, import("../../authConfig/sessionUtils").SUser>;
+};
+//# sourceMappingURL=backupServerFunctions.d.ts.map

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backupServerFunctions.d.ts","sourceRoot":"","sources":["../../../../../src/serverFunctions/adminServerFunctions/backupServerFunctions.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkKhC,CAAC"}

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backupServerFunctions = void 0;
+const utils_1 = require("../../../../common/utils");
+const index_1 = require("../../index");
+const prostglesOnReady_1 = require("../../init/prostglesOnReady");
+const tableConfigBackups_1 = require("../../tableConfig/tableConfigBackups");
+const prostgles_server_1 = require("prostgles-server");
+const prostgles_types_1 = require("prostgles-types");
+const defineFunctionGroup_1 = require("../defineFunctionGroup");
+exports.backupServerFunctions = (0, defineFunctionGroup_1.defineFunctionGroupFunctions)({
+    backupConnections: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: {
+            connectionNames: { optional: true, type: "string[]" },
+            allActive: { optional: true, type: "boolean" },
+            name: "string",
+        },
+        run: async ({ connectionNames: _connectionNames, allActive, name }, { dbo: dbs }) => {
+            const connectionNames = _connectionNames ?? [];
+            const backupManager = (0, prostglesOnReady_1.getBackupManager)();
+            const connectionIds = allActive ?
+                index_1.connectionManager.connections
+                    ?.map((c) => {
+                    const active = index_1.connectionManager.getActiveConnectionSilentFail(c.id);
+                    if (c.is_state_db || active) {
+                        return c.id;
+                    }
+                })
+                    .filter(prostgles_types_1.isDefined)
+                : await dbs.connections.find({
+                    name: { $in: connectionNames },
+                }, { select: { id: 1 }, returnType: "values" });
+            if (!connectionIds?.length) {
+                throw "No connection names provided/active";
+            }
+            if (connectionIds.length !== connectionNames.length && !allActive) {
+                throw "Some connection names were not found";
+            }
+            for (const conId of connectionIds) {
+                await backupManager.pgDump(conId, null, {
+                    name,
+                    options: utils_1.DEFAULT_DUMP_OPTS.options,
+                });
+            }
+        },
+    }),
+    restoreConnections: (0, prostgles_server_1.defineFunction)({
+        unrestrictedDbAccess: true,
+        input: {
+            backupName: "string",
+        },
+        run: async ({ backupName }, { dbo: dbs }) => {
+            const backups = await dbs.backups.find({
+                name: backupName,
+            });
+            if (!backups.length) {
+                return 0;
+            }
+            const backupsWithConnectionIds = backups.map(({ id, connection_id }) => {
+                if (!connection_id) {
+                    throw `Backup with id ${id} does not have a connection_id, cannot restore`;
+                }
+                return { id, connection_id };
+            });
+            for (const { id, connection_id } of backupsWithConnectionIds) {
+                const backupManager = (0, prostglesOnReady_1.getBackupManager)();
+                await backupManager.pgRestore({ bkpId: id, connId: connection_id }, undefined, utils_1.DEFAULT_RESTORE_OPTS);
+            }
+            return backupsWithConnectionIds.length;
+        },
+    }),
+    pgDump: (0, prostgles_server_1.defineFunction)({
+        input: {
+            conId: "string",
+            credId: { oneOf: ["number", { enum: [null] }] },
+            opts: {
+                type: {
+                    name: { type: "string", optional: true },
+                    initiator: { type: "string", optional: true },
+                    options: tableConfigBackups_1.DUMP_OPTIONS_SCHEMA.jsonbSchema,
+                },
+            },
+        },
+        run: ({ conId, credId, opts }) => {
+            const backupManager = (0, prostglesOnReady_1.getBackupManager)();
+            return backupManager.pgDump(conId, credId, opts);
+        },
+    }),
+    pgRestore: (0, prostgles_server_1.defineFunction)({
+        input: {
+            bkpId: "string",
+            connId: { type: "string", optional: true },
+            opts: "any",
+        },
+        run: async ({ bkpId, opts, connId }) => (0, prostglesOnReady_1.getBackupManager)().pgRestore({ bkpId, connId }, undefined, opts),
+    }),
+    bkpDelete: (0, prostgles_server_1.defineFunction)({
+        input: {
+            bkpId: "string",
+            force: { type: "boolean", optional: true },
+        },
+        run: ({ bkpId, force }) => (0, prostglesOnReady_1.getBackupManager)().bkpDelete(bkpId, force),
+    }),
+    streamBackupFile: (0, prostgles_server_1.defineFunction)({
+        input: {
+            data: {
+                oneOfType: [
+                    {
+                        type: { enum: ["start"] },
+                        fileName: "string",
+                        connectionId: "string",
+                        sizeBytes: "integer",
+                        restoreOptions: {
+                            type: tableConfigBackups_1.RESTORE_OPTIONS_SCHEMA["jsonbSchemaType"],
+                        },
+                    },
+                    {
+                        type: { enum: ["chunk"] },
+                        streamId: "string",
+                        chunk: "Blob",
+                    },
+                    {
+                        type: { enum: ["end"] },
+                        streamId: "string",
+                    },
+                ],
+            },
+        },
+        run: async ({ data }, { user }) => {
+            const backupManager = (0, prostglesOnReady_1.getBackupManager)();
+            if (data.type === "start") {
+                const stream = backupManager.getTempFileStream(data.fileName, user.id);
+                await backupManager.pgRestoreStream(data.fileName, data.connectionId, stream.stream, data.sizeBytes, data.restoreOptions);
+                return stream.streamId;
+            }
+            else if (data.type === "chunk") {
+                return new Promise((resolve, reject) => {
+                    backupManager.pushToStream(data.streamId, data.chunk, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(data.streamId);
+                        }
+                    });
+                });
+            }
+            else {
+                backupManager.closeStream(data.streamId);
+            }
+        },
+    }),
+});
+//# sourceMappingURL=backupServerFunctions.js.map

package/dist/server/src/serverFunctions/adminServerFunctions/backupServerFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backupServerFunctions.js","sourceRoot":"","sources":["../../../../../src/serverFunctions/adminServerFunctions/backupServerFunctions.ts"],"names":[],"mappings":"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"}