@webtypen/webframez-core 0.3.47 → 0.3.49

package/README.md

@@ -617,6 +617,8 @@ export default {
     outputDir: "storage/backups",
     filename: "{key}_{date}_{time}",
     zip: true,
+    zipDriver: "auto",
+    zipCompressionLevel: 6,
     cleanupWorkDir: true,
     retention: {
       keepLast: 10,
@@ -665,10 +667,12 @@ export default {
 
 Built-in backup commands:
 - `backup:list`
-- `backup:run <key> [--dry-run] [--channel=local]`
+- `backup:run <key> [--dry-run] [--channel=local] [--silent]`
 - `backup:queue <key> [--worker=worker_1] [--priority=10]`
 - `backup:cleanup <key> [--channel=local] [--dry-run]`
 
+ZIP artifacts use the system `zip` binary by default when available and fall back to the built-in Node.js ZIP writer. Set `zipDriver: "system"` to require system zip, `zipDriver: "node"` to force the built-in writer, or `zipDriver: "auto"` for fallback behavior. `zipCompressionLevel` accepts `0` through `9`.
+
 Remote outputs are optional packages and must be registered by the application before the backup config is used:
 
 ```ts

package/dist/Api/ApiFunctionUtils.d.ts

@@ -54,77 +54,48 @@ export declare function apiFunctionParamToJsonSchema(definition: ApiFunctionPara
     type: string;
     pattern?: undefined;
     items?: undefined;
-    anyOf?: undefined;
+    additionalProperties?: undefined;
+    required?: undefined;
+    properties?: undefined;
     "x-webframez-type"?: undefined;
     enum?: undefined;
 } | {
     type: string;
     pattern: string;
     items?: undefined;
-    anyOf?: undefined;
+    additionalProperties?: undefined;
+    required?: undefined;
+    properties?: undefined;
     "x-webframez-type"?: undefined;
     enum?: undefined;
 } | {
     type: string;
     items: {};
     pattern?: undefined;
-    anyOf?: undefined;
+    additionalProperties?: undefined;
+    required?: undefined;
+    properties?: undefined;
     "x-webframez-type"?: undefined;
     enum?: undefined;
 } | {
-    anyOf: ({
-        type: string;
-        additionalProperties: boolean;
-        properties: {
-            download_url: {
-                type: string;
-            };
-            file_id: {
-                type: string;
-            };
-            mime_type: {
-                type: string;
-            };
-            file_name: {
-                type: string;
-            };
-            url: {
-                type: string;
-            };
-            download_link: {
-                type: string;
-            };
-            file_url: {
-                type: string;
-            };
-            content_base64: {
-                type: string;
-            };
-            data_url: {
-                type: string;
-            };
-            id: {
-                type: string;
-            };
-            filename: {
-                type: string;
-            };
-            name: {
-                type: string;
-            };
-            mime: {
-                type: string;
-            };
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        download_url: {
+            type: string;
+        };
+        file_id: {
+            type: string;
         };
-        description?: undefined;
-    } | {
-        type: string;
-        description: string;
-        additionalProperties?: undefined;
-        properties?: undefined;
-    })[];
+        mime_type: {
+            type: string;
+        };
+        file_name: {
+            type: string;
+        };
+    };
     "x-webframez-type": string;
-    type?: undefined;
     pattern?: undefined;
     items?: undefined;
     enum?: undefined;
@@ -133,7 +104,9 @@ export declare function apiFunctionParamToJsonSchema(definition: ApiFunctionPara
     type?: undefined;
     pattern?: undefined;
     items?: undefined;
-    anyOf?: undefined;
+    additionalProperties?: undefined;
+    required?: undefined;
+    properties?: undefined;
     "x-webframez-type"?: undefined;
 };
 export declare function toApiFunctionHttpResult(res: Response, result: any): Response;

package/dist/Api/ApiFunctionUtils.js

@@ -254,10 +254,7 @@ function coerceApiFunctionParam(key, value, definition) {
         if (isPlainApiObject(value)) {
             return value;
         }
-        if (typeof value === "string") {
-            return value;
-        }
-        throw new ApiFunctionRuntimeError(`Parameter "${key}" must be a file reference string or object`, 400);
+        throw new ApiFunctionRuntimeError(`Parameter "${key}" must be an OpenAI file reference object`, 400);
     }
     return value;
 }
@@ -303,31 +300,15 @@ function apiFunctionParamToJsonSchema(definition) {
         return { type: "object" };
     if (type === "file") {
         return {
-            anyOf: [
-                {
-                    type: "object",
-                    additionalProperties: true,
-                    properties: {
-                        download_url: { type: "string" },
-                        file_id: { type: "string" },
-                        mime_type: { type: "string" },
-                        file_name: { type: "string" },
-                        url: { type: "string" },
-                        download_link: { type: "string" },
-                        file_url: { type: "string" },
-                        content_base64: { type: "string" },
-                        data_url: { type: "string" },
-                        id: { type: "string" },
-                        filename: { type: "string" },
-                        name: { type: "string" },
-                        mime: { type: "string" },
-                    },
-                },
-                {
-                    type: "string",
-                    description: "Connector runtime file reference string. Local paths must be rewritten by the ChatGPT connector before reaching the server.",
-                },
-            ],
+            type: "object",
+            additionalProperties: true,
+            required: ["download_url", "file_id"],
+            properties: {
+                download_url: { type: "string" },
+                file_id: { type: "string" },
+                mime_type: { type: "string" },
+                file_name: { type: "string" },
+            },
             "x-webframez-type": "file",
         };
     }

package/dist/Backup/BackupManager.d.ts

@@ -4,11 +4,14 @@ type ResolvedBackupTypeConfig = BackupTypeConfig & {
     outputDir: string;
     filename: string;
     zip: boolean;
+    zipDriver: "auto" | "system" | "node";
+    zipCompressionLevel?: number;
     cleanupWorkDir: boolean;
     retention?: BackupRetentionConfig;
     outputs: BackupOutputConfig[];
 };
 export declare class BackupManager {
+    private log;
     getConfig(): BackupConfig;
     listTypes(): {
         key: string;

package/dist/Backup/BackupManager.js

@@ -40,6 +40,12 @@ function normalizeArray(value) {
     return value && Array.isArray(value) ? value : [];
 }
 class BackupManager {
+    log(options, message, payload) {
+        if ((options === null || options === void 0 ? void 0 : options.silent) || !(options === null || options === void 0 ? void 0 : options.log)) {
+            return;
+        }
+        options.log(message, payload);
+    }
     getConfig() {
         const config = Config_1.Config.get("backup");
         if (!config || typeof config !== "object") {
@@ -62,7 +68,7 @@ class BackupManager {
         }
         const defaults = config.defaults || {};
         const outputDir = backupType.outputDir || defaults.outputDir || "storage/backups";
-        return Object.assign(Object.assign(Object.assign({}, defaults), backupType), { workDir: backupType.workDir || defaults.workDir || "storage/backups/.work", outputDir: outputDir, filename: backupType.filename || defaults.filename || "{key}_{date}_{time}", zip: backupType.zip !== undefined ? backupType.zip : defaults.zip !== undefined ? defaults.zip : true, cleanupWorkDir: backupType.cleanupWorkDir !== undefined
+        return Object.assign(Object.assign(Object.assign({}, defaults), backupType), { workDir: backupType.workDir || defaults.workDir || "storage/backups/.work", outputDir: outputDir, filename: backupType.filename || defaults.filename || "{key}_{date}_{time}", zip: backupType.zip !== undefined ? backupType.zip : defaults.zip !== undefined ? defaults.zip : true, zipDriver: backupType.zipDriver || defaults.zipDriver || "auto", zipCompressionLevel: backupType.zipCompressionLevel !== undefined ? backupType.zipCompressionLevel : defaults.zipCompressionLevel, cleanupWorkDir: backupType.cleanupWorkDir !== undefined
                 ? backupType.cleanupWorkDir
                 : defaults.cleanupWorkDir !== undefined
                     ? defaults.cleanupWorkDir
@@ -191,28 +197,21 @@ class BackupManager {
             };
         });
     }
-    buildArtifact(key, backupType, workRunDir, contentDir, date, id) {
+    buildArtifact(key, backupType, workRunDir, contentDir, date, id, options) {
         const filename = (0, BackupPathUtils_1.formatBackupFilename)(backupType.filename, { key, date, id });
         if (backupType.zip) {
             const zipPath = path_1.default.join(workRunDir, `${filename}.zip`);
-            const files = [];
-            const walk = (dir) => {
-                for (const entry of fs_1.default.readdirSync(dir)) {
-                    const filepath = path_1.default.join(dir, entry);
-                    const stats = fs_1.default.statSync(filepath);
-                    if (stats.isDirectory()) {
-                        walk(filepath);
-                    }
-                    else if (stats.isFile()) {
-                        files.push({
-                            source: filepath,
-                            name: (0, BackupPathUtils_1.normalizeBackupPath)(path_1.default.relative(contentDir, filepath)),
-                        });
-                    }
-                }
-            };
-            walk(contentDir);
-            (0, ZipWriter_1.createZipFile)(zipPath, files);
+            this.log(options, `Creating ZIP artifact '${path_1.default.basename(zipPath)}'`, {
+                driver: backupType.zipDriver,
+                compressionLevel: backupType.zipCompressionLevel,
+            });
+            const zipResult = (0, ZipWriter_1.createZipFileFromDirectory)(zipPath, contentDir, {
+                driver: backupType.zipDriver,
+                compressionLevel: backupType.zipCompressionLevel,
+            });
+            this.log(options, `ZIP artifact created using ${zipResult.driver} zip`, {
+                path: zipPath,
+            });
             return {
                 path: zipPath,
                 filename: path_1.default.basename(zipPath),
@@ -228,10 +227,11 @@ class BackupManager {
         };
     }
     run(key, options) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const backupType = this.resolveType(key);
             this.ensureActive(key, backupType);
+            this.log(options, `Starting backup '${key}'`);
             const now = new Date();
             const id = (0, BackupPathUtils_1.backupTimestampId)(now);
             const workRoot = (0, BackupPathUtils_1.resolveProjectPath)(backupType.workDir);
@@ -252,13 +252,17 @@ class BackupManager {
                 files: [],
                 databases: [],
             };
+            this.log(options, "Collecting file sources");
             const fileEntries = normalizeArray(backupType.files).flatMap((source) => this.collectFilesFromSource(source));
+            const fileSize = fileEntries.reduce((sum, entry) => sum + entry.size, 0);
+            this.log(options, `Collected ${fileEntries.length} file(s)`, { size: fileSize });
             result.files = fileEntries.map((entry) => ({
                 from: entry.source,
                 to: entry.target,
                 size: entry.size,
             }));
             if (options === null || options === void 0 ? void 0 : options.dryRun) {
+                this.log(options, "Dry run enabled; skipping artifact and output writes");
                 result.outputs = outputs.map((output) => ({
                     driver: output.driver,
                     status: "skipped",
@@ -275,28 +279,44 @@ class BackupManager {
             fs_1.default.rmSync(workRunDir, { recursive: true, force: true });
             fs_1.default.mkdirSync(contentDir, { recursive: true });
             try {
+                this.log(options, `Copying ${fileEntries.length} file(s) into backup work directory`);
                 this.copyFiles(fileEntries, contentDir);
+                this.log(options, "File copy finished");
                 for (const source of normalizeArray(backupType.databases)) {
+                    this.log(options, `Backing up database '${source.connection || "default"}'`);
                     result.databases.push(yield this.backupDatabase(source, contentDir, { backupKey: key, backupId: id }));
+                    this.log(options, `Database '${source.connection || "default"}' backup finished`);
                 }
-                result.artifact = this.buildArtifact(key, backupType, workRunDir, contentDir, now, id);
+                result.artifact = this.buildArtifact(key, backupType, workRunDir, contentDir, now, id, options);
                 const manifestPath = path_1.default.join(workRunDir, `${result.artifact.filename}.run-manifest.json`);
                 result.manifestPath = manifestPath;
                 for (const output of outputs) {
                     const retention = mergeRetention((_a = this.getConfig().defaults) === null || _a === void 0 ? void 0 : _a.retention, backupType.retention, output.retention);
                     const driver = BackupOutputDrivers_1.BackupOutputDrivers.get(output.driver);
+                    this.log(options, `Writing artifact to '${output.driver}' output`, {
+                        path: output.path,
+                        folderPath: output.folderPath,
+                    });
                     const outputResult = yield driver.write(result.artifact, output, {
                         backupKey: key,
                         backupId: id,
                         retention: retention,
                     });
                     result.outputs.push(outputResult);
+                    this.log(options, `Output '${output.driver}' finished with status '${outputResult.status}'`, {
+                        path: outputResult.path,
+                        error: outputResult.error,
+                    });
                     if (outputResult.status === "success" && (retention === null || retention === void 0 ? void 0 : retention.runAfterBackup)) {
+                        this.log(options, `Running cleanup for '${output.driver}' output`);
                         result.cleanup.push(yield driver.cleanup(output, { backupKey: key, backupId: id, retention: retention }, { dryRun: false }));
+                        this.log(options, `Cleanup for '${output.driver}' output finished`, {
+                            deleted: ((_b = result.cleanup[result.cleanup.length - 1]) === null || _b === void 0 ? void 0 : _b.deleted.length) || 0,
+                        });
                     }
                 }
                 result.endedAt = new Date().toISOString();
-                const outputManifestPath = (_b = result.outputs.find((output) => output.payload && output.payload.manifestPath)) === null || _b === void 0 ? void 0 : _b.payload.manifestPath;
+                const outputManifestPath = (_c = result.outputs.find((output) => output.payload && output.payload.manifestPath)) === null || _c === void 0 ? void 0 : _c.payload.manifestPath;
                 if (outputManifestPath) {
                     result.manifestPath = outputManifestPath;
                 }
@@ -307,10 +327,12 @@ class BackupManager {
                         fs_1.default.writeFileSync(output.payload.manifestPath, manifestJson, "utf-8");
                     }
                 }
+                this.log(options, `Backup '${key}' finished`);
                 return result;
             }
             finally {
                 if (backupType.cleanupWorkDir) {
+                    this.log(options, "Cleaning backup work directory");
                     fs_1.default.rmSync(workRunDir, { recursive: true, force: true });
                 }
             }

package/dist/Backup/BackupTypes.d.ts

@@ -32,6 +32,8 @@ export type BackupDefaultsConfig = {
     outputDir?: string;
     filename?: string;
     zip?: boolean;
+    zipDriver?: "auto" | "system" | "node";
+    zipCompressionLevel?: number;
     cleanupWorkDir?: boolean;
     retention?: BackupRetentionConfig;
 };
@@ -100,6 +102,8 @@ export type BackupRunResult = {
 export type BackupRunOptions = {
     dryRun?: boolean;
     channels?: string[];
+    silent?: boolean;
+    log?: (message: string, payload?: any) => void;
 };
 export type BackupCleanupOptions = {
     dryRun?: boolean;

package/dist/Backup/Jobs/BackupRunJob.js

@@ -22,6 +22,7 @@ class BackupRunJob extends BaseQueueJob_1.BaseQueueJob {
             this.log(`Starting backup '${backupKey}'`);
             const result = yield new BackupManager_1.BackupManager().run(backupKey, {
                 channels: job.payload.channels,
+                log: (message, payload) => this.log(message, payload),
             });
             this.log(`Backup '${backupKey}' finished`, {
                 id: result.id,

package/dist/Backup/Utils/ZipWriter.d.ts

@@ -2,3 +2,13 @@ export declare function createZipFile(zipPath: string, files: Array<{
     source: string;
     name: string;
 }>): string;
+export declare function createZipFileFromDirectory(zipPath: string, sourceDir: string, options?: {
+    driver?: "auto" | "system" | "node";
+    compressionLevel?: number;
+}): {
+    path: string;
+    driver: "system";
+} | {
+    path: string;
+    driver: "node";
+};

package/dist/Backup/Utils/ZipWriter.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZipFile = void 0;
+exports.createZipFileFromDirectory = exports.createZipFile = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const zlib_1 = __importDefault(require("zlib"));
+const child_process_1 = require("child_process");
 const BackupPathUtils_1 = require("./BackupPathUtils");
 const crcTable = (() => {
     const table = [];
@@ -118,3 +119,51 @@ function createZipFile(zipPath, files) {
     return zipPath;
 }
 exports.createZipFile = createZipFile;
+function collectZipFiles(sourceDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs_1.default.readdirSync(dir)) {
+            const filepath = path_1.default.join(dir, entry);
+            const stats = fs_1.default.statSync(filepath);
+            if (stats.isDirectory()) {
+                walk(filepath);
+            }
+            else if (stats.isFile()) {
+                files.push({
+                    source: filepath,
+                    name: (0, BackupPathUtils_1.normalizeBackupPath)(path_1.default.relative(sourceDir, filepath)),
+                });
+            }
+        }
+    };
+    walk(sourceDir);
+    return files;
+}
+function compressionArg(level) {
+    if (level === undefined || level === null || Number.isNaN(level)) {
+        return "-6";
+    }
+    const normalized = Math.max(0, Math.min(9, Math.round(level)));
+    return `-${normalized}`;
+}
+function createZipFileFromDirectory(zipPath, sourceDir, options) {
+    var _a;
+    fs_1.default.mkdirSync(path_1.default.dirname(zipPath), { recursive: true });
+    if ((options === null || options === void 0 ? void 0 : options.driver) !== "node") {
+        const args = ["-q", compressionArg(options === null || options === void 0 ? void 0 : options.compressionLevel), "-r", zipPath, "."];
+        const result = (0, child_process_1.spawnSync)("zip", args, {
+            cwd: sourceDir,
+            encoding: "utf-8",
+        });
+        if (result.status === 0 && fs_1.default.existsSync(zipPath)) {
+            return { path: zipPath, driver: "system" };
+        }
+        if ((options === null || options === void 0 ? void 0 : options.driver) === "system") {
+            const detail = result.stderr || result.stdout || ((_a = result.error) === null || _a === void 0 ? void 0 : _a.message) || "unknown error";
+            throw new Error(`System zip failed: ${detail}`);
+        }
+    }
+    createZipFile(zipPath, collectZipFiles(sourceDir));
+    return { path: zipPath, driver: "node" };
+}
+exports.createZipFileFromDirectory = createZipFileFromDirectory;

package/dist/Commands/BackupRunCommand.js

@@ -32,7 +32,12 @@ class BackupRunCommand extends ConsoleCommand_1.ConsoleCommand {
             const result = yield new BackupManager_1.BackupManager().run(key, {
                 dryRun: this.getOption("dry-run") === true,
                 channels: parseChannels(this.getOption("channel")),
+                silent: this.getOption("silent") === true,
+                log: (message) => this.writeln(`  [color=grey]${message}[/color]`),
             });
+            if (this.getOption("silent") === true) {
+                return;
+            }
             if (result.dryRun) {
                 this.info(`Dry run for backup '${key}' finished.`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.47",
+    "version": "0.3.49",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",