@driveflux/reporter 5.7.1 → 5.8.0

package/dist/config.d.ts

@@ -1,21 +1,194 @@
 import { ProblemSeverity } from '@driveflux/problem';
-import type { Configuration } from 'rollbar';
-export type Config = {
+import z from 'zod';
+export declare const ConfigValidation: z.ZodEffects<z.ZodObject<{
+    isProd: z.ZodBoolean;
+    deferReporting: z.ZodBoolean;
+    slack: z.ZodOptional<z.ZodObject<{
+        errorChannelId: z.ZodString;
+        token: z.ZodString;
+        minimumSeverity: z.ZodNativeEnum<typeof ProblemSeverity>;
+    }, "strip", z.ZodTypeAny, {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    }, {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    }>>;
+    drivers: z.ZodObject<{
+        slack: z.ZodBoolean;
+        rollbar: z.ZodBoolean;
+        console: z.ZodBoolean;
+        'sentry-nextjs': z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
+    }, {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
+    }>;
+    rollbar: z.ZodOptional<z.ZodObject<{
+        accessToken: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        accessToken: string;
+        enabled: boolean;
+    }, {
+        accessToken: string;
+        enabled: boolean;
+    }>>;
+    sentry: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        org: z.ZodString;
+        project: z.ZodString;
+        dsn: z.ZodString;
+        authToken: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    }, {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
     isProd: boolean;
     deferReporting: boolean;
+    drivers: {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
+    };
     slack?: {
         errorChannelId: string;
         token: string;
         minimumSeverity: ProblemSeverity;
+    } | undefined;
+    rollbar?: {
+        accessToken: string;
+        enabled: boolean;
+    } | undefined;
+    sentry?: {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    } | undefined;
+}, {
+    isProd: boolean;
+    deferReporting: boolean;
+    drivers: {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
     };
+    slack?: {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    } | undefined;
+    rollbar?: {
+        accessToken: string;
+        enabled: boolean;
+    } | undefined;
+    sentry?: {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    } | undefined;
+}>, {
+    isProd: boolean;
+    deferReporting: boolean;
     drivers: {
         slack: boolean;
         rollbar: boolean;
         console: boolean;
+        'sentry-nextjs': boolean;
     };
-    rollbar?: Configuration;
-};
+    slack?: {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    } | undefined;
+    rollbar?: {
+        accessToken: string;
+        enabled: boolean;
+    } | undefined;
+    sentry?: {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    } | undefined;
+}, {
+    isProd: boolean;
+    deferReporting: boolean;
+    drivers: {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
+    };
+    slack?: {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    } | undefined;
+    rollbar?: {
+        accessToken: string;
+        enabled: boolean;
+    } | undefined;
+    sentry?: {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    } | undefined;
+}>;
+export type Config = z.infer<typeof ConfigValidation>;
 export declare let config: Config;
-export declare const resetConfig: () => Config;
+export declare const resetConfig: () => {
+    isProd: boolean;
+    deferReporting: boolean;
+    drivers: {
+        slack: boolean;
+        rollbar: boolean;
+        console: boolean;
+        'sentry-nextjs': boolean;
+    };
+    slack?: {
+        errorChannelId: string;
+        token: string;
+        minimumSeverity: ProblemSeverity;
+    } | undefined;
+    rollbar?: {
+        accessToken: string;
+        enabled: boolean;
+    } | undefined;
+    sentry?: {
+        url: string;
+        org: string;
+        project: string;
+        dsn: string;
+        authToken?: string | undefined;
+    } | undefined;
+};
 export declare const setConfig: <Key extends keyof Config>(key: Key, value: Config[Key]) => void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,MAAM,MAAM,MAAM,GAAG;IACpB,MAAM,EAAE,OAAO,CAAA;IACf,cAAc,EAAE,OAAO,CAAA;IACvB,KAAK,CAAC,EAAE;QACP,cAAc,EAAE,MAAM,CAAA;QACtB,KAAK,EAAE,MAAM,CAAA;QACb,eAAe,EAAE,eAAe,CAAA;KAChC,CAAA;IACD,OAAO,EAAE;QACR,KAAK,EAAE,OAAO,CAAA;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;KAChB,CAAA;IACD,OAAO,CAAC,EAAE,aAAa,CAAA;CACvB,CAAA;AA6BD,eAAO,IAAI,MAAM,EAAE,MAAiD,CAAA;AAEpE,eAAO,MAAM,WAAW,cAIvB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,GAAG,SAAS,MAAM,MAAM,OAC5C,GAAG,SACD,MAAM,CAAC,GAAG,CAAC,SAGlB,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD1B,CAAA;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AA8CrD,eAAO,IAAI,MAAM,EAAE,MAA2D,CAAA;AAE9E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAIvB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,GAAG,SAAS,MAAM,MAAM,OAC5C,GAAG,SACD,MAAM,CAAC,GAAG,CAAC,SAGlB,CAAA"}

package/dist/config.js

@@ -1,31 +1,89 @@
 import { ProblemSeverity } from '@driveflux/problem';
-import { singleton } from '@driveflux/singleton';
+import { initSingleton } from '@driveflux/singleton';
+import z from 'zod';
+export var ConfigValidation = z.object({
+    isProd: z.boolean(),
+    deferReporting: z.boolean(),
+    slack: z.object({
+        errorChannelId: z.string(),
+        token: z.string(),
+        minimumSeverity: z.nativeEnum(ProblemSeverity)
+    }).optional(),
+    drivers: z.object({
+        slack: z.boolean(),
+        rollbar: z.boolean(),
+        console: z.boolean(),
+        'sentry-nextjs': z.boolean()
+    }),
+    rollbar: z.object({
+        accessToken: z.string(),
+        enabled: z.boolean()
+    }).optional(),
+    sentry: z.object({
+        url: z.string(),
+        org: z.string(),
+        project: z.string(),
+        dsn: z.string(),
+        authToken: z.string().optional()
+    }).optional()
+}).superRefine(function(data, ctx) {
+    if (data.drivers.rollbar && !data.rollbar) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Rollbar is required when using the Rollbar driver'
+        });
+    }
+    if (data.drivers['sentry-nextjs'] && !data.sentry) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Sentry is required when using the Sentry driver'
+        });
+    }
+    if (data.drivers.rollbar && !data.rollbar) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Rollbar is required when using the Rollbar driver'
+        });
+    }
+});
 var getConfig = function() {
-    return {
+    return ConfigValidation.parse({
         isProd: process.env.APP_ENV === 'production',
         deferReporting: typeof process.env.REPORTER_DEFER === 'string' && process.env.REPORTER_DEFER !== '' ? process.env.REPORTER_DEFER === 'true' : true,
-        slack: {
+        slack: process.env.REPORTER_USE_SLACK === 'true' ? {
             errorChannelId: process.env.SLACK_ERROR_CHANNEL,
             token: process.env.SLACK_TOKEN,
             minimumSeverity: ProblemSeverity.CRITICAL
-        },
+        } : undefined,
         drivers: {
             slack: process.env.REPORTER_USE_SLACK === 'true',
             rollbar: process.env.REPORTER_USE_ROLLBAR === 'true',
-            console: process.env.REPORTER_USE_CONSOLE !== 'false'
+            console: process.env.REPORTER_USE_CONSOLE !== 'false',
+            'sentry-nextjs': process.env.REPORTER_USE_SENTRY_NEXTJS === 'true'
         },
-        rollbar: {
+        sentry: process.env.REPORTER_USE_SENTRY_NEXTJS === 'true' ? {
+            url: process.env.SENTRY_URL,
+            org: process.env.SENTRY_ORG,
+            project: process.env.SENTRY_PROJECT,
+            dsn: process.env.SENTRY_DSN,
+            authToken: process.env.SENTRY_AUTH_TOKEN
+        } : undefined,
+        rollbar: process.env.REPORTER_USE_ROLLBAR === 'true' ? {
             accessToken: process.env.ROLLBAR_ACCESS_TOKEN,
             enabled: true,
             captureUncaught: true,
             captureUnhandledRejections: true,
             environment: process.env.APP_ENV || process.env.NODE_ENV
-        }
-    };
+        } : undefined
+    });
 };
-export var config = singleton('reporterConfig', getConfig());
+export var config = initSingleton('reporterConfig', function() {
+    return getConfig();
+});
 export var resetConfig = function() {
-    config = singleton('reporterConfig', getConfig(), true);
+    config = initSingleton('reporterConfig', function() {
+        return getConfig();
+    }, true);
     return config;
 };
 export var setConfig = function(key, value) {

package/dist/drivers/sentry-nextjs.d.ts

@@ -0,0 +1,13 @@
+import type { Problem } from '@driveflux/problem';
+import * as Sentry from '@sentry/nextjs';
+import type { Config } from '../config.js';
+import type { Metadata, Reporter } from '../types.js';
+export declare class SentryNextJSDriver implements Reporter {
+    private config;
+    constructor(config: NonNullable<Config['sentry']>);
+    getSentry(): typeof Sentry;
+    reportError(err: Error, metadata: Metadata): Promise<void>;
+    reportProblem(problem: Problem): Promise<void>;
+    setReporterPayload(payload: Record<string, any>): void;
+}
+//# sourceMappingURL=sentry-nextjs.d.ts.map

package/dist/drivers/sentry-nextjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry-nextjs.d.ts","sourceRoot":"","sources":["../../src/drivers/sentry-nextjs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAA;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAErD,qBAAa,kBAAmB,YAAW,QAAQ;IACtC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAMzD,SAAS;IAIH,WAAW,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ;IAQ1C,aAAa,CAAC,OAAO,EAAE,OAAO;IAapC,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG/C"}

package/dist/drivers/sentry-nextjs.js

@@ -0,0 +1,219 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import * as Sentry from '@sentry/nextjs';
+export var SentryNextJSDriver = /*#__PURE__*/ function() {
+    "use strict";
+    function SentryNextJSDriver(config) {
+        _class_call_check(this, SentryNextJSDriver);
+        _define_property(this, "config", void 0);
+        this.config = config;
+        if (!this.config) {
+            throw new Error('Sentry is not configured');
+        }
+    }
+    _create_class(SentryNextJSDriver, [
+        {
+            key: "getSentry",
+            value: function getSentry() {
+                return Sentry;
+            }
+        },
+        {
+            key: "reportError",
+            value: function reportError(err, metadata) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        Sentry.captureException(err, {
+                            contexts: {
+                                metadata: metadata
+                            }
+                        });
+                        return [
+                            2
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "reportProblem",
+            value: function reportProblem(problem) {
+                return _async_to_generator(function() {
+                    var _problem_privateMetadata;
+                    return _ts_generator(this, function(_state) {
+                        Sentry.captureException(((_problem_privateMetadata = problem.privateMetadata) === null || _problem_privateMetadata === void 0 ? void 0 : _problem_privateMetadata.error) || new Error(problem.message || problem.code), {
+                            contexts: {
+                                metadata: problem.metadata,
+                                privateMetadata: problem.privateMetadata
+                            }
+                        });
+                        return [
+                            2
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "setReporterPayload",
+            value: function setReporterPayload(payload) {
+                Sentry.setContext('reporterPayload', payload);
+            }
+        }
+    ]);
+    return SentryNextJSDriver;
+}();

package/dist/index.d.ts

@@ -1,8 +1,20 @@
 import { type Problem } from '@driveflux/problem';
+import { type Config } from './config.js';
+import { ConsoleDriver } from './drivers/console.js';
+import { RollbarDriver } from './drivers/rollbar.js';
+import { SentryNextJSDriver } from './drivers/sentry-nextjs.js';
+import { SlackDriver } from './drivers/slack.js';
 import type { Metadata, Reporter } from './types.js';
+type Driver = keyof Config['drivers'];
 export * from './config.js';
 export declare const addDriver: (name: string, reporter: Reporter, enabled?: boolean) => void;
-export declare const getDriver: (driver: string) => Reporter;
+declare const DRIVERS_MAP: {
+    readonly console: () => ConsoleDriver;
+    readonly rollbar: () => RollbarDriver;
+    readonly 'sentry-nextjs': () => SentryNextJSDriver;
+    readonly slack: () => SlackDriver;
+};
+export declare const getDriver: <D extends string>(driver: D) => D extends Driver ? ReturnType<(typeof DRIVERS_MAP)[D]> : Reporter;
 export declare const reportError: (err: Error, metadata?: Metadata, sync?: boolean) => Promise<Error>;
 /**
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,oBAAoB,CAAA;AAO7D,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAIpD,cAAc,aAAa,CAAA;AAY3B,eAAO,MAAM,SAAS,SAAU,MAAM,YAAY,QAAQ,4BAKzD,CAAA;AAED,eAAO,MAAM,SAAS,WAAY,MAAM,KAAG,QAqB1C,CAAA;AAkBD,eAAO,MAAM,WAAW,QAClB,KAAK,aACA,QAAQ,SACX,OAAO,mBAUd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,YAAmB,OAAO,SAAS,OAAO,qBASnE,CAAA;AAED,eAAO,MAAM,qBAAqB,qBAYjC,CAAA;AAgCD,eAAO,MAAM,kBAAkB,YAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,SAI9D,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,oBAAoB,CAAA;AAG7D,OAAO,EAAE,KAAK,MAAM,EAAU,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAEpD,KAAK,MAAM,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAA;AAErC,cAAc,aAAa,CAAA;AAY3B,eAAO,MAAM,SAAS,SAAU,MAAM,YAAY,QAAQ,4BAKzD,CAAA;AAED,QAAA,MAAM,WAAW;;;;;CAekC,CAAA;AAEnD,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,UACjC,CAAC,KACP,CAAC,SAAS,MAAM,GAAG,UAAU,CAAC,CAAC,OAAO,WAAW,EAAE,CAAC,CAAC,CAAC,GAAG,QAW3D,CAAA;AAkBD,eAAO,MAAM,WAAW,QAClB,KAAK,aACA,QAAQ,SACX,OAAO,mBAUd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,YAAmB,OAAO,SAAS,OAAO,qBASnE,CAAA;AAED,eAAO,MAAM,qBAAqB,qBAYjC,CAAA;AAgCD,eAAO,MAAM,kBAAkB,YAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,SAI9D,CAAA"}

package/dist/index.js

@@ -205,12 +205,13 @@ import { omit } from '@driveflux/utils';
 import { config } from './config.js';
 import { ConsoleDriver } from './drivers/console.js';
 import { RollbarDriver } from './drivers/rollbar.js';
+import { SentryNextJSDriver } from './drivers/sentry-nextjs.js';
 import { SlackDriver } from './drivers/slack.js';
 export * from './config.js';
-var problemsAndErrorsToReport = initSingleton('reporterProblemsAndErrors', function() {
+var problemsAndErrorsToReport = initSingleton('reporter_problemsAndErrors', function() {
     return new Set();
 });
-var customDrivers = initSingleton('reporterCustomDrivers', function() {
+var customDrivers = initSingleton('reporter_customDrivers', function() {
     return new Map();
 });
 export var addDriver = function(name, reporter) {
@@ -220,28 +221,37 @@ export var addDriver = function(name, reporter) {
         reporter: reporter
     });
 };
-export var getDriver = function(driver) {
-    switch(driver){
-        case 'console':
+var DRIVERS_MAP = {
+    console: function() {
+        return initSingleton('reporter_consoleDriver', function() {
             return new ConsoleDriver();
-        case 'rollbar':
+        });
+    },
+    rollbar: function() {
+        return initSingleton('reporter_rollbarDriver', function() {
             return new RollbarDriver(config.rollbar);
-        case 'slack':
-            {
-                if (!config.slack) {
-                    throw new Error('Slack config missing');
-                }
-                return new SlackDriver(config.slack);
-            }
-        default:
-            {
-                var customDriver = customDrivers.get(driver);
-                if (!customDriver) {
-                    throw new Error("Driver ".concat(driver, " not found."));
-                }
-                return customDriver.reporter;
-            }
+        });
+    },
+    'sentry-nextjs': function() {
+        return initSingleton('reporter_sentryDriver', function() {
+            return new SentryNextJSDriver(config.sentry);
+        });
+    },
+    slack: function() {
+        return initSingleton('reporter_slackDriver', function() {
+            return new SlackDriver(config.slack);
+        });
+    }
+};
+export var getDriver = function(driver) {
+    if (driver in DRIVERS_MAP) {
+        return DRIVERS_MAP[driver]();
+    }
+    var customDriver = customDrivers.get(driver);
+    if (!customDriver) {
+        throw new Error("Driver ".concat(driver, " not found."));
     }
+    return customDriver.reporter;
 };
 var getDrivers = function() {
     var allDrivers = _to_consumable_array(Object.keys(config.drivers)).concat(_to_consumable_array(customDrivers.keys()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driveflux/reporter",
-  "version": "5.7.1",
+  "version": "5.8.0",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
@@ -15,10 +15,6 @@
     "./types": {
       "types": "./dist/types.d.ts",
       "import": "./dist/types.js"
-    },
-    "./sentry/nextjs": {
-      "types": "./dist/sentry-nextjs.d.ts",
-      "import": "./dist/sentry-nextjs.js"
     }
   },
   "files": [
@@ -29,11 +25,12 @@
     "@driveflux/problem": "4.3.0",
     "@driveflux/redact": "4.3.0",
     "@driveflux/singleton": "1.5.0",
-    "@driveflux/utils": "3.3.2",
+    "@driveflux/utils": "4.0.0",
     "@sentry/nextjs": "^8.41.0",
     "@sentry/node": "^8.35.0",
     "flat": "6.0.1",
-    "rollbar": "^2.26.4"
+    "rollbar": "^2.26.4",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@driveflux/fab": "2.3.3",

package/dist/sentry-nextjs.js

@@ -1 +0,0 @@
-export * from '@sentry/nextjs';