@trigger.dev/core-backend - npm Package Compare versions

Comparing version 0.0.0-invoke-trigger-20231103104037 to 0.0.0-nestfix-20240322145612

dist/index.d.ts

@@ -12,2 +12,15 @@ declare class BloomFilter {
 
-export { BloomFilter };
+type LogLevel = "log" | "error" | "warn" | "info" | "debug";
+declare class Logger {
+    #private;
+    constructor(name: string, level?: LogLevel, filteredKeys?: string[], jsonReplacer?: (key: string, value: unknown) => unknown, additionalFields?: () => Record<string, unknown>);
+    filter(...keys: string[]): Logger;
+    static satisfiesLogLevel(logLevel: LogLevel, setLevel: LogLevel): boolean;
+    log(message: string, ...args: Array<Record<string, unknown> | undefined>): void;
+    error(message: string, ...args: Array<Record<string, unknown> | undefined>): void;
+    warn(message: string, ...args: Array<Record<string, unknown> | undefined>): void;
+    info(message: string, ...args: Array<Record<string, unknown> | undefined>): void;
+    debug(message: string, ...args: Array<Record<string, unknown> | undefined>): void;
+}
+
+export { BloomFilter, type LogLevel, Logger };

dist/index.js

@@ -1,21 +0,9 @@
-"use strict";
+'use strict';
+
+var node_buffer = require('node:buffer');
+var node_process = require('node:process');
+
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
@@ -25,12 +13,24 @@ __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 };
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BloomFilter: () => BloomFilter
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/bloom.ts
-var import_node_buffer = require("buffer");
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var _BloomFilter = class _BloomFilter {
@@ -51,3 +51,3 @@ constructor(size) {
   serialize() {
-    return import_node_buffer.Buffer.from(this.bitArray).toString("base64");
+    return node_buffer.Buffer.from(this.bitArray).toString("base64");
   }
@@ -57,3 +57,3 @@ // Deserialize from a Base64 string
     const filter = new _BloomFilter(size);
-    filter.bitArray = Uint8Array.from(import_node_buffer.Buffer.from(str, "base64"));
+    filter.bitArray = Uint8Array.from(node_buffer.Buffer.from(str, "base64"));
     return filter;
@@ -87,2 +87,165 @@ }
 __name(murmurHash3, "murmurHash3");
+var logLevels = [
+  "log",
+  "error",
+  "warn",
+  "info",
+  "debug"
+];
+var _name, _level, _filteredKeys, _jsonReplacer, _additionalFields, _structuredLog, structuredLog_fn;
+var _Logger = class _Logger {
+  constructor(name, level = "info", filteredKeys = [], jsonReplacer, additionalFields) {
+    __privateAdd(this, _structuredLog);
+    __privateAdd(this, _name, void 0);
+    __privateAdd(this, _level, void 0);
+    __privateAdd(this, _filteredKeys, []);
+    __privateAdd(this, _jsonReplacer, void 0);
+    __privateAdd(this, _additionalFields, void 0);
+    __privateSet(this, _name, name);
+    __privateSet(this, _level, logLevels.indexOf(node_process.env.TRIGGER_LOG_LEVEL ?? level));
+    __privateSet(this, _filteredKeys, filteredKeys);
+    __privateSet(this, _jsonReplacer, createReplacer(jsonReplacer));
+    __privateSet(this, _additionalFields, additionalFields ?? (() => ({})));
+  }
+  // Return a new Logger instance with the same name and a new log level
+  // but filter out the keys from the log messages (at any level)
+  filter(...keys) {
+    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
+  }
+  static satisfiesLogLevel(logLevel, setLevel) {
+    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
+  }
+  log(message, ...args) {
+    if (__privateGet(this, _level) < 0)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (__privateGet(this, _level) < 1)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (__privateGet(this, _level) < 2)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (__privateGet(this, _level) < 3)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (__privateGet(this, _level) < 4)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
+  }
+};
+_name = new WeakMap();
+_level = new WeakMap();
+_filteredKeys = new WeakMap();
+_jsonReplacer = new WeakMap();
+_additionalFields = new WeakMap();
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
+  const structuredLog = {
+    ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
+    ...__privateGet(this, _additionalFields).call(this),
+    timestamp: /* @__PURE__ */ new Date(),
+    name: __privateGet(this, _name),
+    message,
+    level
+  };
+  loggerFunction(JSON.stringify(structuredLog, __privateGet(this, _jsonReplacer)));
+}, "#structuredLog");
+__name(_Logger, "Logger");
+var Logger = _Logger;
+function createReplacer(replacer) {
+  return (key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (replacer) {
+      return replacer(key, value);
+    }
+    return value;
+  };
+}
+__name(createReplacer, "createReplacer");
+function bigIntReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+__name(bigIntReplacer, "bigIntReplacer");
+function safeJsonClone(obj) {
+  try {
+    return JSON.parse(JSON.stringify(obj, bigIntReplacer));
+  } catch (e) {
+    return;
+  }
+}
+__name(safeJsonClone, "safeJsonClone");
+function structureArgs(args, filteredKeys = []) {
+  if (!args) {
+    return;
+  }
+  if (args.length === 0) {
+    return;
+  }
+  if (args.length === 1 && typeof args[0] === "object") {
+    return filterKeys(JSON.parse(JSON.stringify(args[0], bigIntReplacer)), filteredKeys);
+  }
+  return args;
+}
+__name(structureArgs, "structureArgs");
+function filterKeys(obj, keys) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => filterKeys(item, keys));
+  }
+  const filteredObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (keys.includes(key)) {
+      if (value) {
+        filteredObj[key] = `[filtered ${prettyPrintBytes(value)}]`;
+      } else {
+        filteredObj[key] = value;
+      }
+      continue;
+    }
+    filteredObj[key] = filterKeys(value, keys);
+  }
+  return filteredObj;
+}
+__name(filterKeys, "filterKeys");
+function prettyPrintBytes(value) {
+  if (node_process.env.NODE_ENV === "production") {
+    return "skipped size";
+  }
+  const sizeInBytes = getSizeInBytes(value);
+  if (sizeInBytes < 1024) {
+    return `${sizeInBytes} bytes`;
+  }
+  if (sizeInBytes < 1024 * 1024) {
+    return `${(sizeInBytes / 1024).toFixed(2)} KB`;
+  }
+  if (sizeInBytes < 1024 * 1024 * 1024) {
+    return `${(sizeInBytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  return `${(sizeInBytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+__name(prettyPrintBytes, "prettyPrintBytes");
+function getSizeInBytes(value) {
+  const jsonString = JSON.stringify(value);
+  return node_buffer.Buffer.byteLength(jsonString, "utf8");
+}
+__name(getSizeInBytes, "getSizeInBytes");
+
+exports.BloomFilter = BloomFilter;
+exports.Logger = Logger;
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@trigger.dev/core-backend",
-  "version": "0.0.0-invoke-trigger-20231103104037",
+  "version": "0.0.0-nestfix-20240322145612",
   "description": "Core code used across `@trigger.dev/sdk` and Trigger.dev server",
@@ -8,2 +8,3 @@ "license": "MIT",
   "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
   "publishConfig": {
@@ -17,4 +18,8 @@ "access": "public"
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
@@ -30,5 +35,6 @@ "./package.json": "./package.json"
     "ts-jest": "^29.1.1",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.0",
-    "@trigger.dev/tsconfig": "0.0.0"
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.0",
+    "@trigger.dev/tsconfig": "0.0.0",
+    "@trigger.dev/tsup": "0.0.0"
   },
@@ -35,0 +41,0 @@ "engines": {

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

Improved metrics

Total package byte prevSize

46959

increased by422.99%

Number of package files

8

increased by60%

Lines of code

507

increased by451.09%

Worsened metrics

Dev dependency count

9

increased by12.5%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes