@defer/client - npm Package Compare versions

Comparing version 1.0.0-alpha-20230225194947-ece6604 to 2.0.0-alpha-20230225204614-f9e6d83

cjs/constants.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERNAL_VERSION = exports.FN_EXECUTION_POLLING_INTERVAL_SECS = exports.TOKEN_ENV_NAME = exports.PATH = exports.DOMAIN = void 0;
-exports.DOMAIN = "https://api.defer.run";
-exports.PATH = "/api/v1/";
-exports.TOKEN_ENV_NAME = "DEFER_TOKEN";
-exports.FN_EXECUTION_POLLING_INTERVAL_SECS = 2;
+exports.INTERNAL_VERSION = void 0;
 exports.INTERNAL_VERSION = 3;

cjs/index.js

@@ -6,38 +6,54 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delay = exports.defer = exports.isDeferExecution = exports.init = void 0;
+exports.delay = exports.defer = exports.configure = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const parse_duration_1 = __importDefault(require("parse-duration"));
 // @ts-expect-error untyped dep
 const natural_cron_js_1 = __importDefault(require("@darkeyedevelopers/natural-cron.js"));
 const constants_js_1 = require("./constants.js");
-const execute_js_1 = require("./execute.js");
-const fetcher_js_1 = require("./fetcher.js");
-let token = process.env[constants_js_1.TOKEN_ENV_NAME];
-let apiEndpoint = `${constants_js_1.DOMAIN}${constants_js_1.PATH}`;
-let debug = false;
-let fetcher = token ? (0, fetcher_js_1.makeFetcher)(apiEndpoint, token) : undefined;
-const init = ({ apiToken, apiUrl, debug: debugValue }) => {
-    token = apiToken || process.env[constants_js_1.TOKEN_ENV_NAME];
-    apiEndpoint = apiUrl || `${constants_js_1.DOMAIN}${constants_js_1.PATH}`;
-    debug = debugValue || debug;
-    fetcher = token ? (0, fetcher_js_1.makeFetcher)(apiEndpoint, token) : undefined;
-};
-exports.init = init;
-const isDeferExecution = (obj) => !!obj.__deferExecutionResponse;
-exports.isDeferExecution = isDeferExecution;
+const FakeID = "00000000000000000000000000000000";
+const client_js_1 = require("./client.js");
+const errors_js_1 = require("./errors.js");
+const httpClient_js_1 = require("./httpClient.js");
+const withDelay = (dt, delay) => new Date(dt.getTime() + (0, parse_duration_1.default)(delay));
+let __accessToken = process.env["DEFER_TOKEN"];
+let __endpoint = "https://api.defer.run";
+let __verbose = false;
+let __httpClient;
+if (__accessToken)
+    __httpClient = (0, httpClient_js_1.makeHTTPClient)(__endpoint, __accessToken);
+function configure(opts = {}) {
+    if (opts.accessToken)
+        __accessToken = opts.accessToken;
+    if (opts.endpoint)
+        __endpoint = opts.endpoint;
+    if (opts.verbose)
+        __verbose = opts.verbose;
+    if (__accessToken)
+        __httpClient = (0, httpClient_js_1.makeHTTPClient)(__endpoint, __accessToken);
+    return;
+}
+exports.configure = configure;
 const defer = (fn, options) => {
-    const ret = (...args) => {
-        if (debug) {
+    const ret = async (...args) => {
+        if (__verbose)
             console.log(`[defer.run][${fn.name}] invoked.`);
+        let functionArguments;
+        try {
+            functionArguments = JSON.parse(JSON.stringify(args));
         }
-        if (token && fetcher) {
-            return (0, execute_js_1.executeBackgroundFunction)(fn.name, args, fetcher, debug);
+        catch (error) {
+            const e = error;
+            throw new errors_js_1.DeferError(`cannot serialize argument: ${e.message}`);
         }
-        else {
-            if (debug) {
-                console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
-            }
-            // try to serialize arguments for develpment warning purposes
-            (0, execute_js_1.serializeBackgroundFunctionArguments)(fn.name, args);
-            // FIX: do better
-            return fn(...args);
+        if (__httpClient) {
+            return (0, client_js_1.enqueueExecution)(__httpClient, {
+                name: fn.name,
+                arguments: functionArguments,
+                scheduleFor: new Date(),
+            });
         }
+        if (__verbose)
+            console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+        await fn(...functionArguments);
+        return { id: FakeID };
     };
@@ -54,30 +70,44 @@ ret.__fn = fn;
     ret.await = async (...args) => {
-        const executionResult = (await (0, exports.defer)(fn)(...args));
-        if ((0, exports.isDeferExecution)(executionResult)) {
-            return await (0, execute_js_1.poolForExecutionResult)(fn.name, 
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            executionResult.id, 
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            fetcher, debug);
+        let functionArguments;
+        try {
+            functionArguments = JSON.parse(JSON.stringify(args));
         }
-        else {
-            return Promise.resolve(executionResult);
+        catch (error) {
+            const e = error;
+            throw new errors_js_1.DeferError(`cannot serialize argument: ${e.message}`);
         }
-    };
-    ret.delayed = (...args) => {
-        if (debug) {
-            console.log(`[defer.run][${fn.name}] invoked.`);
+        if (__httpClient) {
+            const { id } = await (0, client_js_1.enqueueExecution)(__httpClient, {
+                name: fn.name,
+                arguments: functionArguments,
+                scheduleFor: new Date(),
+            });
+            const response = await (0, client_js_1.waitExecutionResult)(__httpClient, { id: id });
+            if (response.state === "failed") {
+                let error = new Error("Defer execution failed");
+                if (response.result?.message) {
+                    error = new Error(response.result.message);
+                    error.stack = response.result.stack;
+                }
+                else if (response.result) {
+                    error = response.result;
+                }
+                throw error;
+            }
+            return response.result;
         }
-        const [options] = args.splice(-1);
-        if (token && fetcher) {
-            return (0, execute_js_1.executeBackgroundFunction)(fn.name, args, fetcher, debug, options);
+        try {
+            return Promise.resolve(await fn(...functionArguments));
         }
-        else {
-            if (debug) {
-                console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+        catch (error) {
+            // const e = error as Error;
+            let deferError = new Error("Defer execution failed");
+            if (error instanceof Error) {
+                deferError = new Error(error.message);
+                deferError.stack = error.stack || "";
             }
-            // try to serialize arguments for develpment warning purposes
-            (0, execute_js_1.serializeBackgroundFunctionArguments)(fn.name, args);
-            // FIX: do better
-            return fn(...args);
+            else {
+                deferError = error;
+            }
+            throw error;
         }
@@ -106,21 +136,33 @@ };
  */
-const delay = (deferFn, delay) => (...args) => {
+const delay = (deferFn, delay) => async (...args) => {
     const fn = deferFn.__fn;
-    if (debug) {
-        console.log(`[defer.run][${fn.name}] invoked.`);
+    let functionArguments;
+    try {
+        functionArguments = JSON.parse(JSON.stringify(args));
     }
-    if (token && fetcher) {
-        return (0, execute_js_1.executeBackgroundFunction)(fn.name, args, fetcher, debug, {
-            delay,
-        });
+    catch (error) {
+        const e = error;
+        throw new errors_js_1.DeferError(`cannot serialize argument: ${e.message}`);
     }
-    else {
-        if (debug) {
-            console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+    if (__verbose)
+        console.log(`[defer.run][${fn.name}] invoked.`);
+    if (__httpClient) {
+        let scheduleFor;
+        if (delay instanceof Date) {
+            scheduleFor = delay;
         }
-        // try to serialize arguments for develpment warning purposes
-        (0, execute_js_1.serializeBackgroundFunctionArguments)(fn.name, args);
-        // FIX: do better
-        return fn(...args);
+        else {
+            const now = new Date();
+            scheduleFor = withDelay(now, delay);
+        }
+        return (0, client_js_1.enqueueExecution)(__httpClient, {
+            name: fn.name,
+            arguments: functionArguments,
+            scheduleFor: scheduleFor,
+        });
     }
+    if (__verbose)
+        console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+    await fn(...functionArguments);
+    return { id: FakeID };
 };
@@ -127,0 +169,0 @@ exports.delay = delay;

esm/constants.js

@@ -1,5 +0,1 @@
-export const DOMAIN = "https://api.defer.run";
-export const PATH = "/api/v1/";
-export const TOKEN_ENV_NAME = "DEFER_TOKEN";
-export const FN_EXECUTION_POLLING_INTERVAL_SECS = 2;
 export const INTERNAL_VERSION = 3;

esm/index.js

@@ -0,34 +1,51 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import parseDuration from "parse-duration";
 // @ts-expect-error untyped dep
 import getCronString from "@darkeyedevelopers/natural-cron.js";
-import { DOMAIN, INTERNAL_VERSION, PATH, TOKEN_ENV_NAME } from "./constants.js";
-import { executeBackgroundFunction, poolForExecutionResult, serializeBackgroundFunctionArguments, } from "./execute.js";
-import { makeFetcher } from "./fetcher.js";
-let token = process.env[TOKEN_ENV_NAME];
-let apiEndpoint = `${DOMAIN}${PATH}`;
-let debug = false;
-let fetcher = token ? makeFetcher(apiEndpoint, token) : undefined;
-export const init = ({ apiToken, apiUrl, debug: debugValue }) => {
-    token = apiToken || process.env[TOKEN_ENV_NAME];
-    apiEndpoint = apiUrl || `${DOMAIN}${PATH}`;
-    debug = debugValue || debug;
-    fetcher = token ? makeFetcher(apiEndpoint, token) : undefined;
-};
-export const isDeferExecution = (obj) => !!obj.__deferExecutionResponse;
+import { INTERNAL_VERSION } from "./constants.js";
+const FakeID = "00000000000000000000000000000000";
+import { enqueueExecution, waitExecutionResult, } from "./client.js";
+import { DeferError } from "./errors.js";
+import { makeHTTPClient } from "./httpClient.js";
+const withDelay = (dt, delay) => new Date(dt.getTime() + parseDuration(delay));
+let __accessToken = process.env["DEFER_TOKEN"];
+let __endpoint = "https://api.defer.run";
+let __verbose = false;
+let __httpClient;
+if (__accessToken)
+    __httpClient = makeHTTPClient(__endpoint, __accessToken);
+export function configure(opts = {}) {
+    if (opts.accessToken)
+        __accessToken = opts.accessToken;
+    if (opts.endpoint)
+        __endpoint = opts.endpoint;
+    if (opts.verbose)
+        __verbose = opts.verbose;
+    if (__accessToken)
+        __httpClient = makeHTTPClient(__endpoint, __accessToken);
+    return;
+}
 export const defer = (fn, options) => {
-    const ret = (...args) => {
-        if (debug) {
+    const ret = async (...args) => {
+        if (__verbose)
             console.log(`[defer.run][${fn.name}] invoked.`);
+        let functionArguments;
+        try {
+            functionArguments = JSON.parse(JSON.stringify(args));
         }
-        if (token && fetcher) {
-            return executeBackgroundFunction(fn.name, args, fetcher, debug);
+        catch (error) {
+            const e = error;
+            throw new DeferError(`cannot serialize argument: ${e.message}`);
         }
-        else {
-            if (debug) {
-                console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
-            }
-            // try to serialize arguments for develpment warning purposes
-            serializeBackgroundFunctionArguments(fn.name, args);
-            // FIX: do better
-            return fn(...args);
+        if (__httpClient) {
+            return enqueueExecution(__httpClient, {
+                name: fn.name,
+                arguments: functionArguments,
+                scheduleFor: new Date(),
+            });
         }
+        if (__verbose)
+            console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+        await fn(...functionArguments);
+        return { id: FakeID };
     };
@@ -45,30 +62,44 @@ ret.__fn = fn;
     ret.await = async (...args) => {
-        const executionResult = (await defer(fn)(...args));
-        if (isDeferExecution(executionResult)) {
-            return await poolForExecutionResult(fn.name, 
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            executionResult.id, 
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            fetcher, debug);
+        let functionArguments;
+        try {
+            functionArguments = JSON.parse(JSON.stringify(args));
         }
-        else {
-            return Promise.resolve(executionResult);
+        catch (error) {
+            const e = error;
+            throw new DeferError(`cannot serialize argument: ${e.message}`);
         }
-    };
-    ret.delayed = (...args) => {
-        if (debug) {
-            console.log(`[defer.run][${fn.name}] invoked.`);
+        if (__httpClient) {
+            const { id } = await enqueueExecution(__httpClient, {
+                name: fn.name,
+                arguments: functionArguments,
+                scheduleFor: new Date(),
+            });
+            const response = await waitExecutionResult(__httpClient, { id: id });
+            if (response.state === "failed") {
+                let error = new Error("Defer execution failed");
+                if (response.result?.message) {
+                    error = new Error(response.result.message);
+                    error.stack = response.result.stack;
+                }
+                else if (response.result) {
+                    error = response.result;
+                }
+                throw error;
+            }
+            return response.result;
         }
-        const [options] = args.splice(-1);
-        if (token && fetcher) {
-            return executeBackgroundFunction(fn.name, args, fetcher, debug, options);
+        try {
+            return Promise.resolve(await fn(...functionArguments));
         }
-        else {
-            if (debug) {
-                console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+        catch (error) {
+            // const e = error as Error;
+            let deferError = new Error("Defer execution failed");
+            if (error instanceof Error) {
+                deferError = new Error(error.message);
+                deferError.stack = error.stack || "";
             }
-            // try to serialize arguments for develpment warning purposes
-            serializeBackgroundFunctionArguments(fn.name, args);
-            // FIX: do better
-            return fn(...args);
+            else {
+                deferError = error;
+            }
+            throw error;
         }
@@ -96,21 +127,33 @@ };
  */
-export const delay = (deferFn, delay) => (...args) => {
+export const delay = (deferFn, delay) => async (...args) => {
     const fn = deferFn.__fn;
-    if (debug) {
-        console.log(`[defer.run][${fn.name}] invoked.`);
+    let functionArguments;
+    try {
+        functionArguments = JSON.parse(JSON.stringify(args));
     }
-    if (token && fetcher) {
-        return executeBackgroundFunction(fn.name, args, fetcher, debug, {
-            delay,
-        });
+    catch (error) {
+        const e = error;
+        throw new DeferError(`cannot serialize argument: ${e.message}`);
     }
-    else {
-        if (debug) {
-            console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+    if (__verbose)
+        console.log(`[defer.run][${fn.name}] invoked.`);
+    if (__httpClient) {
+        let scheduleFor;
+        if (delay instanceof Date) {
+            scheduleFor = delay;
         }
-        // try to serialize arguments for develpment warning purposes
-        serializeBackgroundFunctionArguments(fn.name, args);
-        // FIX: do better
-        return fn(...args);
+        else {
+            const now = new Date();
+            scheduleFor = withDelay(now, delay);
+        }
+        return enqueueExecution(__httpClient, {
+            name: fn.name,
+            arguments: functionArguments,
+            scheduleFor: scheduleFor,
+        });
     }
+    if (__verbose)
+        console.log(`[defer.run][${fn.name}] defer ignore, no token found.`);
+    await fn(...functionArguments);
+    return { id: FakeID };
 };
@@ -117,0 +160,0 @@ // EXAMPLES:

package.json

 {
   "name": "@defer/client",
-  "version": "1.0.0-alpha-20230225194947-ece6604",
+  "version": "2.0.0-alpha-20230225204614-f9e6d83",
   "description": "Zero infrastructure NodeJS background jobs",
@@ -12,3 +12,3 @@ "dependencies": {
   "author": "Defer Inc <[e-mail]>",
-  "license": "MIT",
+  "license": "ISC",
   "main": "cjs/index.js",
@@ -15,0 +15,0 @@ "module": "esm/index.js",

typings/constants.d.ts

@@ -1,5 +0,1 @@
-export declare const DOMAIN = "https://api.defer.run";
-export declare const PATH = "/api/v1/";
-export declare const TOKEN_ENV_NAME = "DEFER_TOKEN";
-export declare const FN_EXECUTION_POLLING_INTERVAL_SECS = 2;
 export declare const INTERNAL_VERSION = 3;

typings/index.d.ts

@@ -1,10 +0,9 @@
-import type { Units } from "parse-duration";
-import { DeferExecuteResponse } from "./execute.js";
-export type { DeferExecuteResponse } from "./execute.js";
+import { Units } from "parse-duration";
+import { EnqueueExecutionResponse } from "./client.js";
 interface Options {
-    apiToken?: string;
-    apiUrl?: string;
-    debug?: boolean;
+    accessToken?: string;
+    endpoint?: string;
+    verbose?: boolean;
 }
-export declare const init: ({ apiToken, apiUrl, debug: debugValue }: Options) => void;
+export declare function configure(opts?: Options): void;
 export declare type UnPromise<F> = F extends Promise<infer R> ? R : F;
@@ -27,9 +26,5 @@ export declare type DelayString = `${string}${Units}`;
 export interface DeferRetFn<F extends (...args: any | undefined) => Promise<any>> extends HasDeferMetadata {
-    (...args: Parameters<F>): ReturnType<F>;
+    (...args: Parameters<F>): Promise<EnqueueExecutionResponse>;
     __fn: F;
     await: DeferAwaitRetFn<F>;
-    /**
-     * @deprecated use `delay(deferFn)` instead
-     */
-    delayed: (...args: DeferRetFnParameters<F>) => ReturnType<F>;
 }
@@ -47,3 +42,2 @@ export interface DeferScheduledFn<F extends (...args: never) => Promise<any>> extends HasDeferMetadata {
 }
-export declare const isDeferExecution: (obj: any) => obj is DeferExecuteResponse;
 export interface DeferOptions {
@@ -55,3 +49,3 @@ retry?: boolean | RetryNumber;
 interface DeferDelay {
-    <F extends (...args: any | undefined) => Promise<any>>(deferFn: DeferRetFn<F>, delay: DelayString | Date): (...args: Parameters<F>) => ReturnType<F>;
+    <F extends (...args: any | undefined) => Promise<any>>(deferFn: DeferRetFn<F>, delay: DelayString | Date): (...args: Parameters<F>) => Promise<EnqueueExecutionResponse>;
 }
@@ -66,1 +60,2 @@ /**
 export declare const delay: DeferDelay;
+export {};

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Fixed alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 2 instances in 1 package

Improved metrics

Total package byte prevSize

36808

increased by14.57%

Number of package files

28

increased by40%

Lines of code

824

increased by28.55%

Number of low supply chain risk alerts

3

decreased by-40%

Worsened metrics

Number of medium supply chain risk alerts

2

increased by100%

No dependency changes