@datatruck/cli 0.30.0 → 0.31.0

package/utils/http.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.readRequestData = exports.closeServer = void 0;
+exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.fetch = exports.readRequestData = exports.closeServer = void 0;
 const math_1 = require("./math");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
@@ -37,14 +37,15 @@ function readRequestData(req) {
     });
 }
 exports.readRequestData = readRequestData;
-async function fetchJson(url, options = {}) {
+async function fetch(url, options = {}) {
+    const throwStatusCodeError = options.statusError ?? true;
     return new Promise((resolve, reject) => {
         let data;
         request(href(url, options.query), {
             method: "GET",
             headers: options.headers,
         }, (res) => {
-            if (res.statusCode !== 200)
+            if (throwStatusCodeError && res.statusCode !== 200)
                 return reject(new Error(`GET failed: ${res.statusCode} ${res.statusMessage}`));
             res
                 .on("data", (chunk) => {
@@ -54,23 +55,20 @@ async function fetchJson(url, options = {}) {
             })
                 .on("error", reject)
                 .on("close", () => {
-                if (data === undefined) {
-                    resolve(undefined);
-                }
-                else {
-                    try {
-                        resolve(JSON.parse(data));
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                }
+                resolve({ data, status: res.statusCode });
             });
         })
             .on("error", reject)
             .end();
     });
 }
+exports.fetch = fetch;
+async function fetchJson(url, options = {}) {
+    const res = await fetch(url, options);
+    if (res.data === undefined)
+        return;
+    return JSON.parse(res.data);
+}
 exports.fetchJson = fetchJson;
 async function post(url, data, options = {}) {
     await new Promise((resolve, reject) => {
@@ -114,7 +112,10 @@ async function downloadFile(url, output, options = {}) {
                 }
                 res
                     .on("error", async (error) => {
-                    file.destroy();
+                    try {
+                        file.destroy();
+                    }
+                    catch (_) { }
                     try {
                         await (0, promises_1.unlink)(output);
                     }

package/utils/object.d.ts

@@ -1,5 +1,5 @@
 export declare function merge<T extends Record<string, unknown>>(target: T, ...sources: Record<string, unknown>[]): T;
-export declare function push<T>(map: Record<string, T[]>, key: string, object: T): void;
+export declare function omitProp<T extends Record<string, any>, N extends keyof T>(object: T, name: N): Omit<T, N>;
 export declare function getErrorProperties(error: Error): Record<string, string>;
 type GroupByKeyParamType<TItem> = ((item: TItem) => string[] | string) | (keyof TItem)[] | keyof TItem;
 export declare function groupBy<TItem>(items: TItem[], keyOrCb: GroupByKeyParamType<TItem>): Record<string, TItem[]>;

package/utils/object.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = exports.getErrorProperties = exports.push = exports.merge = void 0;
+exports.groupBy = exports.getErrorProperties = exports.omitProp = exports.merge = void 0;
 function merge(target, ...sources) {
     const isObject = (o) => typeof o === "object" && o !== null;
     for (const source of sources)
@@ -13,12 +13,12 @@ function merge(target, ...sources) {
     return target;
 }
 exports.merge = merge;
-function push(map, key, object) {
-    if (!map[key])
-        map[key] = [];
-    map[key].push(object);
+function omitProp(object, name) {
+    const result = { ...object };
+    delete result[name];
+    return result;
 }
-exports.push = push;
+exports.omitProp = omitProp;
 function getErrorProperties(error) {
     const alt = {};
     for (const key of Object.getOwnPropertyNames(error)) {

package/utils/progress.d.ts

@@ -17,29 +17,36 @@ export type Progress = {
     absolute?: ProgressStats;
     relative?: ProgressStats;
 };
+export type ProgressTty = "auto" | boolean;
+export type ProgressMode = "auto" | "interval" | `interval:${number}` | boolean;
 export declare class ProgressManager {
     readonly options: {
         verbose?: boolean;
         /**
-         * @default true
+         * @default false
          */
-        tty?: boolean | "auto";
-        enabled?: boolean | "auto" | "interval";
-        interval?: number;
+        tty?: ProgressTty;
+        /**
+         * @default "interval"
+         */
+        mode?: ProgressMode;
     };
     protected timer: Timer;
     protected interval: Timer | undefined;
+    protected intervalMs: number;
     protected keydownListener: ((data: Buffer | undefined) => void) | undefined;
-    readonly tty: boolean;
-    readonly enabled: boolean | "interval";
+    readonly tty: Exclude<ProgressTty, "auto">;
+    readonly mode: Exclude<ProgressMode, "auto" | `interval:${number}`>;
     constructor(options: {
         verbose?: boolean;
         /**
-         * @default true
+         * @default false
+         */
+        tty?: ProgressTty;
+        /**
+         * @default "interval"
          */
-        tty?: boolean | "auto";
-        enabled?: boolean | "auto" | "interval";
-        interval?: number;
+        mode?: ProgressMode;
     });
     elapsed(): number;
     start(): void;

package/utils/progress.js

@@ -11,9 +11,10 @@ class ProgressManager {
     options;
     timer = (0, date_1.createTimer)();
     interval = (0, date_1.createTimer)();
+    intervalMs;
     keydownListener;
     tty;
-    enabled;
+    mode;
     constructor(options) {
         this.options = options;
         this.tty =
@@ -22,12 +23,21 @@ class ProgressManager {
                     ? false
                     : process.stdout.isTTY
                 : !!options.tty;
-        this.enabled =
-            options.enabled === "auto"
-                ? this.tty
-                    ? true
-                    : "interval"
-                : !!options.enabled;
+        const mode = options.mode === "auto"
+            ? this.tty
+                ? `interval:${300}`
+                : "interval"
+            : options.mode ?? "interval";
+        this.intervalMs = 1000;
+        if (typeof mode === "string" && mode.startsWith("interval:")) {
+            const [, ms] = mode.split(":");
+            this.mode = "interval";
+            if (/^\d+$/.test(ms))
+                this.intervalMs = Number(ms);
+        }
+        else {
+            this.mode = mode;
+        }
     }
     elapsed() {
         return this.timer.elapsed();
@@ -57,11 +67,11 @@ class ProgressManager {
         }
     }
     update(progress, cb) {
-        if (!this.enabled)
+        if (!this.mode)
             return;
-        if (this.enabled === "interval") {
+        if (this.mode === "interval") {
             if (this.interval) {
-                if (!this.interval.reset(this.options.interval ?? 5000))
+                if (!this.interval.reset(this.intervalMs))
                     return;
             }
             else {

package/utils/schema.d.ts

@@ -0,0 +1,34 @@
+import { JSONSchema7 } from "json-schema";
+export declare function omitPropertySchema<T extends {
+    properties: Record<string, any>;
+}, N extends keyof T["properties"]>(object: T, name: N): Omit<T, "properties"> & {
+    properties: Omit<T["properties"], N>;
+};
+type IfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7> = {
+    if: {
+        type: "object";
+        properties: {
+            [k in KType]: {
+                const: T;
+            };
+        };
+    };
+    then: {
+        type: "object";
+        properties: {
+            [k in KValue]: V;
+        };
+    };
+    else: false;
+};
+export declare function createCaseSchema<KType extends string, KValue extends string, V extends {
+    [K in KType]: JSONSchema7;
+}>(keys: {
+    type: KType;
+    value: KValue;
+}, value: V): IfSchema<KType, KValue, string, JSONSchema7>[];
+export declare function createIfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7>(keys: {
+    type: KType;
+    value: KValue;
+}, type: T, value: V): IfSchema<KType, KValue, T, V>;
+export {};

package/utils/schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIfSchema = exports.createCaseSchema = exports.omitPropertySchema = void 0;
+const object_1 = require("./object");
+function omitPropertySchema(object, name) {
+    return {
+        ...object,
+        properties: (0, object_1.omitProp)(object.properties, name),
+    };
+}
+exports.omitPropertySchema = omitPropertySchema;
+function createCaseSchema(keys, value) {
+    return Object.entries(value).reduce((schemas, [type, value]) => {
+        schemas.push(createIfSchema(keys, type, value));
+        return schemas;
+    }, []);
+}
+exports.createCaseSchema = createCaseSchema;
+function createIfSchema(keys, type, value) {
+    return {
+        if: {
+            type: "object",
+            properties: {
+                [keys.type]: { const: type },
+            },
+        },
+        then: {
+            type: "object",
+            properties: {
+                [keys.value]: value,
+            },
+        },
+        else: false,
+    };
+}
+exports.createIfSchema = createIfSchema;

package/utils/string.d.ts

@@ -1,4 +1,3 @@
-export declare function serialize(message: string, data?: Object): string;
 export declare function snakeCase(value: string, char?: string): string;
 export declare function render(subject: string, vars: Record<string, string | undefined>): string;
 type NoInfer<T> = [T][T extends any ? 0 : never];
@@ -12,12 +11,10 @@ export type UriType = {
     path?: string;
 };
 export declare function formatUri(input: UriType, hidePassword?: boolean): string;
-export declare function formatSeconds(seconds: number): string;
 export declare function makePathPatterns(values: string[] | undefined): string[] | undefined;
 export declare function match(path: string, include?: string[], exclude?: string[]): boolean;
 export declare function endsWith(input: string, patterns: string[]): boolean;
 export declare function createMatchFilter(include?: string[], exclude?: string[]): (input: string) => boolean;
 export declare function checkMatch(subject: string | undefined, patterns: string[]): boolean;
-export declare function formatDateTime(datetime: string): string;
 export declare function undefIfEmpty(input: string): string | undefined;
 export {};

package/utils/string.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undefIfEmpty = exports.formatDateTime = exports.checkMatch = exports.createMatchFilter = exports.endsWith = exports.match = exports.makePathPatterns = exports.formatSeconds = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = exports.serialize = void 0;
+exports.undefIfEmpty = exports.checkMatch = exports.createMatchFilter = exports.endsWith = exports.match = exports.makePathPatterns = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = void 0;
 const AppError_1 = require("../Error/AppError");
 const micromatch_1 = require("micromatch");
-function serialize(message, data) {
-    if (data)
-        return `${message} (${JSON.stringify(data, null, 2)})`;
-    return message;
-}
-exports.serialize = serialize;
 function snakeCase(value, char = "_") {
     return value.replace(/[A-Z]/g, (letter) => `${char}${letter.toLowerCase()}`);
 }
@@ -61,26 +55,6 @@ function formatUri(input, hidePassword) {
     return uri;
 }
 exports.formatUri = formatUri;
-function formatSeconds(seconds) {
-    let unit;
-    let value;
-    if (seconds > 60 * 60) {
-        value = seconds / 60 / 60;
-        unit = `hour`;
-    }
-    else if (seconds > 60) {
-        value = seconds / 60;
-        unit = `minute`;
-    }
-    else {
-        value = seconds;
-        unit = `second`;
-    }
-    if (value !== 1)
-        unit += `s`;
-    return `${value.toFixed(2)} ${unit}`;
-}
-exports.formatSeconds = formatSeconds;
 function makePathPatterns(values) {
     return values?.flatMap((v) => {
         if (v === "*" || v === "**" || v === "<empty>" || v === "!<empty>") {
@@ -111,16 +85,6 @@ function checkMatch(subject, patterns) {
     return (0, micromatch_1.isMatch)(subject, patterns);
 }
 exports.checkMatch = checkMatch;
-function formatDateTime(datetime) {
-    const date = new Date(datetime);
-    const [result] = new Date(date.getTime() - date.getTimezoneOffset() * 60000)
-        .toISOString()
-        .replace("Z", "")
-        .replace("T", " ")
-        .split(".");
-    return result;
-}
-exports.formatDateTime = formatDateTime;
 function undefIfEmpty(input) {
     return input.length ? input : undefined;
 }

package/utils/ObjectVault.d.ts

@@ -1,13 +0,0 @@
-export type KeysType = (string | number)[];
-export declare class ObjectVault<TObject> {
-    protected counter: number;
-    protected readonly ids: Record<string, number>;
-    protected readonly objects: Record<number, TObject>;
-    static serializeKeys(keys: KeysType): string;
-    get(id: number): TObject;
-    getId(keys: KeysType): number;
-    add(options: {
-        keys: KeysType;
-        handler: (id: number) => TObject;
-    }): TObject;
-}

package/utils/ObjectVault.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectVault = void 0;
-class ObjectVault {
-    counter = 0;
-    ids = {};
-    objects = {};
-    static serializeKeys(keys) {
-        return JSON.stringify(keys);
-    }
-    get(id) {
-        if (!(id in this.objects))
-            throw new Error(`Object not found: ${id}`);
-        return this.objects[id];
-    }
-    getId(keys) {
-        const key = ObjectVault.serializeKeys(keys);
-        const id = this.ids[key];
-        if (!id)
-            throw new Error(`Id not found: ${JSON.stringify(keys)}`);
-        return id;
-    }
-    add(options) {
-        const key = ObjectVault.serializeKeys(options.keys);
-        const id = (this.ids[key] = ++this.counter);
-        return (this.objects[id] = options.handler(id));
-    }
-}
-exports.ObjectVault = ObjectVault;