nextjs-cms 0.9.36 → 0.9.37

package/dist/api/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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"}

package/dist/api/server.js

@@ -1,100 +0,0 @@
-import 'server-only';
-import { createHydrationHelpers } from '@trpc/react-query/rsc';
-import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
-import { headers } from 'next/headers';
-import { cache } from 'react';
-import { getConfigImportVersion } from '../core/config/index.js';
-import { loadPlugins } from '../plugins/loader.js';
-import { coreRouters } from './root.js';
-import { createCallerFactory, createTRPCContext, router } from './trpc.js';
-import { createQueryClient } from './trpc/query-client.js';
-import { createAsyncCallerProxy } from './utils/async-caller-proxy.js';
-export function createTRPCRouter(opts = {}) {
-    const userRouters = (opts.routers ?? {});
-    for (const key of Object.keys(userRouters)) {
-        if (key in coreRouters) {
-            throw new Error(`[trpc] Router key "${key}" conflicts with a core router.`);
-        }
-    }
-    const appRouter = router({
-        ...coreRouters,
-        ...userRouters,
-    });
-    let cachedRouter = null;
-    let pendingRouter = null;
-    let cachedVersion = -1;
-    let pendingVersion = -1;
-    async function getMergedRouter() {
-        const currentVersion = getConfigImportVersion();
-        if (cachedRouter && cachedVersion === currentVersion) {
-            return cachedRouter;
-        }
-        if (pendingRouter && pendingVersion === currentVersion) {
-            return pendingRouter;
-        }
-        cachedRouter = null;
-        pendingVersion = currentVersion;
-        pendingRouter = (async () => {
-            const loadedPlugins = await loadPlugins();
-            const pluginRouters = {};
-            const seen = new Set([...Object.keys(coreRouters), ...Object.keys(userRouters)]);
-            for (const plugin of loadedPlugins) {
-                if (!plugin.plugin.router)
-                    continue;
-                if (seen.has(plugin.routerKey)) {
-                    const message = `[plugins] Router key "${plugin.routerKey}" conflicts with core/user router. Skipping.`;
-                    throw new Error(message);
-                }
-                pluginRouters[plugin.routerKey] = plugin.plugin.router;
-                seen.add(plugin.routerKey);
-            }
-            const mergedRouter = router({
-                ...coreRouters,
-                ...pluginRouters,
-                ...userRouters,
-            });
-            cachedRouter = mergedRouter;
-            cachedVersion = currentVersion;
-            return mergedRouter;
-        })();
-        try {
-            return await pendingRouter;
-        }
-        finally {
-            if (pendingVersion === currentVersion) {
-                pendingRouter = null;
-            }
-        }
-    }
-    const createContext = cache(async () => {
-        const heads = new Headers(await headers());
-        heads.set('x-trpc-source', 'rsc');
-        return createTRPCContext({
-            headers: heads,
-        });
-    });
-    const getQueryClient = cache(createQueryClient);
-    const getCaller = cache(async () => (await getMergedRouter()).createCaller(await createContext()));
-    const callerProxy = createAsyncCallerProxy(getCaller);
-    const helpers = createHydrationHelpers(callerProxy, getQueryClient);
-    const handler = async (req) => fetchRequestHandler({
-        endpoint: '/api/trpc',
-        req,
-        router: await getMergedRouter(),
-        createContext: () => createTRPCContext({ headers: req.headers }),
-        onError: opts.onError ??
-            (process.env.NODE_ENV === 'development'
-                ? ({ path, error }) => {
-                    console.error(`tRPC failed on ${path ?? '<no-path>'}: ${error.message}`);
-                }
-                : undefined),
-    });
-    return {
-        appRouter,
-        handler: { GET: handler, POST: handler },
-        api: helpers.trpc,
-        HydrateClient: helpers.HydrateClient,
-        createCaller: createCallerFactory(appRouter),
-        getRouter: getMergedRouter,
-    };
-}

package/dist/api/trpc/error-logging.d.ts

@@ -1,14 +0,0 @@
-type TRPCLogPhase = 'trpc-http-handler' | 'trpc-router-load' | 'trpc-procedure';
-interface LogTRPCErrorOptions {
-    phase: TRPCLogPhase;
-    error: unknown;
-    path?: string | null;
-    type?: string;
-    input?: unknown;
-    req?: Request;
-    source?: string | null;
-}
-export declare function getHeaderValue(headers: unknown, name: string): string | null;
-export declare function logTRPCError({ phase, error, path, type, input, req, source }: LogTRPCErrorOptions): void;
-export {};
-//# sourceMappingURL=error-logging.d.ts.map

package/dist/api/trpc/error-logging.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-logging.d.ts","sourceRoot":"","sources":["../../../src/api/trpc/error-logging.ts"],"names":[],"mappings":"AAEA,KAAK,YAAY,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,gBAAgB,CAAA;AAE/E,UAAU,mBAAmB;IACzB,KAAK,EAAE,YAAY,CAAA;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAkDD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO5E;AAED,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,mBAAmB,GAAG,IAAI,CA4BxG"}

package/dist/api/trpc/error-logging.js

@@ -1,75 +0,0 @@
-import { inspect } from 'node:util';
-const SENSITIVE_KEY_PATTERN = /authorization|cookie|csrf|credential|password|secret|token|key/i;
-const MAX_REDACTION_DEPTH = 8;
-function shouldLogTRPCErrors() {
-    return process.env.NODE_ENV !== 'test' || process.env.NEXTJS_CMS_DEBUG_TRPC === '1';
-}
-function redactSensitiveValues(value, depth = 0, seen = new WeakSet()) {
-    if (depth > MAX_REDACTION_DEPTH)
-        return '[MaxDepth]';
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (value instanceof Date)
-        return value.toISOString();
-    if (value instanceof Error)
-        return serializeError(value);
-    if (Array.isArray(value))
-        return value.map((item) => redactSensitiveValues(item, depth + 1, seen));
-    if (seen.has(value))
-        return '[Circular]';
-    seen.add(value);
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
-        key,
-        SENSITIVE_KEY_PATTERN.test(key) ? '[Redacted]' : redactSensitiveValues(entry, depth + 1, seen),
-    ]));
-}
-function serializeError(error) {
-    if (!(error instanceof Error)) {
-        return inspect(error, { colors: false, depth: null });
-    }
-    const errorWithMetadata = error;
-    return {
-        name: error.name,
-        message: error.message,
-        code: errorWithMetadata.code,
-        digest: errorWithMetadata.digest,
-        stack: error.stack,
-        cause: errorWithMetadata.cause ? serializeError(errorWithMetadata.cause) : undefined,
-        inspected: inspect(error, { colors: false, depth: null }),
-    };
-}
-export function getHeaderValue(headers, name) {
-    if (headers instanceof Headers)
-        return headers.get(name);
-    if (!headers || typeof headers !== 'object')
-        return null;
-    const value = headers[name] ?? headers[name.toLowerCase()];
-    if (Array.isArray(value))
-        return value.join(', ');
-    return typeof value === 'string' ? value : null;
-}
-export function logTRPCError({ phase, error, path, type, input, req, source }) {
-    if (!shouldLogTRPCErrors())
-        return;
-    const payload = {
-        phase,
-        path: path ?? '<no-path>',
-        type,
-        input: input === undefined ? undefined : redactSensitiveValues(input),
-        request: req
-            ? {
-                url: req.url,
-                method: req.method,
-                trpcSource: req.headers.get('x-trpc-source'),
-            }
-            : undefined,
-        trpcSource: source,
-        error: serializeError(error),
-    };
-    console.error('[nextjs-cms] tRPC error', inspect(payload, {
-        colors: false,
-        compact: false,
-        depth: null,
-        breakLength: 120,
-    }));
-}

package/dist/api/trpc.d.ts

@@ -1,111 +0,0 @@
-import superjson from 'superjson';
-/**
- * Creates context for an incoming request
- * @link https://trpc.io/docs/v11/context
- */
-export declare const createTRPCContext: (opts: {
-    headers: Headers;
-}) => Promise<{
-    headers: Headers;
-    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-        $client: import("mysql2/promise").Pool;
-    };
-    session: import("../index.js").Session | null;
-}>;
-type Context = Awaited<ReturnType<typeof createTRPCContext>>;
-export type TRPCContext = Context;
-export declare const transformer: {
-    input: typeof superjson;
-    output: typeof superjson;
-};
-/**
- * Create a server-side caller
- * @see https://trpc.io/docs/server/server-side-calls
- */
-export declare const createCallerFactory: import("@trpc/server").TRPCRouterCallerFactory<{
-    ctx: {
-        headers: Headers;
-        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-            $client: import("mysql2/promise").Pool;
-        };
-        session: import("../index.js").Session | null;
-    };
-    meta: object;
-    errorShape: {
-        data: {
-            zodError: import("zod").ZodFlattenedError<unknown, string> | null;
-            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
-            httpStatus: number;
-            path?: string;
-            stack?: string;
-        };
-        message: string;
-        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
-    };
-    transformer: true;
-}>;
-/**
- * This is how you create new routers and sub-routers in your tRPC API
- * @see https://trpc.io/docs/router
- */
-export declare const router: import("@trpc/server").TRPCRouterBuilder<{
-    ctx: {
-        headers: Headers;
-        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-            $client: import("mysql2/promise").Pool;
-        };
-        session: import("../index.js").Session | null;
-    };
-    meta: object;
-    errorShape: {
-        data: {
-            zodError: import("zod").ZodFlattenedError<unknown, string> | null;
-            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
-            httpStatus: number;
-            path?: string;
-            stack?: string;
-        };
-        message: string;
-        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
-    };
-    transformer: true;
-}>;
-/**
- * Public procedure that doesn't require authentication
- */
-export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
-    headers: Headers;
-    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-        $client: import("mysql2/promise").Pool;
-    };
-    session: import("../index.js").Session | null;
-}, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
-/**
- * Private procedure that uses the `isAuthedMiddleware` middleware to require authentication
- * @see https://trpc.io/docs/procedures
- */
-export declare const privateProcedure: import("@trpc/server").TRPCProcedureBuilder<{
-    headers: Headers;
-    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-        $client: import("mysql2/promise").Pool;
-    };
-    session: import("../index.js").Session | null;
-}, object, {
-    session: {
-        user: import("../index.js").User;
-    };
-}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
-type PrivilegeOperation = 'C' | 'U' | 'D';
-export declare const pluginProcedure: (sectionName: string, requiredRole?: PrivilegeOperation) => import("@trpc/server").TRPCProcedureBuilder<{
-    headers: Headers;
-    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema.js")> & {
-        $client: import("mysql2/promise").Pool;
-    };
-    session: import("../index.js").Session | null;
-}, object, {
-    session: {
-        user: import("../index.js").User;
-    };
-}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
-export {};
-//# sourceMappingURL=trpc.d.ts.map

package/dist/api/trpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/api/trpc.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,WAAW,CAAA;AASjC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,MAAM;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE;aAAT,OAAO;;;;;EAQ/D,CAAA;AAED,KAAK,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAA;AAC5D,MAAM,MAAM,WAAW,GAAG,OAAO,CAAA;AAEjC,eAAO,MAAM,WAAW;;;CAGvB,CAAA;AAkBD;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;iBAtCyB,OAAO;;;;;;;;;;;;;;;;;;;EAsCR,CAAA;AAiBxD;;;GAGG;AACH,eAAO,MAAM,MAAM;;iBA3DsC,OAAO;;;;;;;;;;;;;;;;;;;EA2DlC,CAAA;AAE9B;;GAEG;AACH,eAAO,MAAM,eAAe;aAhE6B,OAAO;;;;;yLAgEtB,CAAA;AAE1C;;;GAGG;AACH,eAAO,MAAM,gBAAgB;aAtE4B,OAAO;;;;;;;;;yKAsEG,CAAA;AAEnE,KAAK,kBAAkB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAoCzC,eAAO,MAAM,eAAe,GAAI,aAAa,MAAM,EAAE,eAAe,kBAAkB;aA5G7B,OAAO;;;;;;;;;yKA6GO,CAAA"}

package/dist/api/trpc.js

@@ -1,99 +0,0 @@
-import { initTRPC, TRPCError } from '@trpc/server';
-import superjson from 'superjson';
-import { ZodError } from 'zod';
-import auth from '../auth/index.js';
-import { db } from '../db/client.js';
-import { and, eq } from 'drizzle-orm';
-import { AdminPrivilegesTable } from '../db/schema.js';
-import getString from '../translations/index.js';
-import { isDashboardOverridePlugin } from '../plugins/loader.js';
-/**
- * Creates context for an incoming request
- * @link https://trpc.io/docs/v11/context
- */
-export const createTRPCContext = async (opts) => {
-    const session = await auth();
-    return {
-        db,
-        session,
-        ...opts,
-    };
-};
-export const transformer = {
-    input: superjson,
-    output: superjson,
-};
-const t = initTRPC.context().create({
-    transformer: transformer,
-    errorFormatter({ shape, error }) {
-        return {
-            ...shape,
-            data: {
-                ...shape.data,
-                zodError: error.cause instanceof ZodError ? error.cause.flatten() : null,
-            },
-        };
-    },
-    /*errorFormatter({ shape }) {
-        return shape
-    },*/
-});
-/**
- * Create a server-side caller
- * @see https://trpc.io/docs/server/server-side-calls
- */
-export const createCallerFactory = t.createCallerFactory;
-const isAuthedMiddleware = t.middleware(async ({ ctx, next }) => {
-    if (!ctx.session || !ctx.session.user)
-        throw new TRPCError({ code: 'UNAUTHORIZED', message: getString('noTokenProvided', 'en') });
-    return next({
-        /*ctx: {
-            user: user,
-            headers: ctx.opts.headers,
-        },*/
-        ctx: {
-            // infers the `session` as non-nullable
-            session: { ...ctx.session, user: ctx.session.user },
-        },
-    });
-});
-/**
- * This is how you create new routers and sub-routers in your tRPC API
- * @see https://trpc.io/docs/router
- */
-export const router = t.router;
-/**
- * Public procedure that doesn't require authentication
- */
-export const publicProcedure = t.procedure;
-/**
- * Private procedure that uses the `isAuthedMiddleware` middleware to require authentication
- * @see https://trpc.io/docs/procedures
- */
-export const privateProcedure = t.procedure.use(isAuthedMiddleware);
-const accessControlMiddleware = (sectionName, requiredRole) => isAuthedMiddleware.unstable_pipe(async ({ ctx, next }) => {
-    // Bypass privilege check for dashboard override plugin
-    if (await isDashboardOverridePlugin(sectionName)) {
-        return next();
-    }
-    const privilege = await db
-        .select()
-        .from(AdminPrivilegesTable)
-        .where(and(eq(AdminPrivilegesTable.adminId, ctx.session.user.id), eq(AdminPrivilegesTable.sectionName, sectionName)))
-        .limit(1);
-    const allowed = privilege[0];
-    if (!allowed) {
-        throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: getString('sectionNotFound', ctx.session.user.language),
-        });
-    }
-    if (requiredRole && !allowed.operations.includes(requiredRole)) {
-        throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: getString('noAccessToThisOperation', ctx.session.user.language),
-        });
-    }
-    return next();
-});
-export const pluginProcedure = (sectionName, requiredRole) => t.procedure.use(accessControlMiddleware(sectionName, requiredRole));

package/dist/api/utils/async-caller-proxy.d.ts

@@ -1,2 +0,0 @@
-export declare function createAsyncCallerProxy<TCaller>(getCaller: () => Promise<TCaller>): TCaller;
-//# sourceMappingURL=async-caller-proxy.d.ts.map

package/dist/api/utils/async-caller-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-caller-proxy.d.ts","sourceRoot":"","sources":["../../../src/api/utils/async-caller-proxy.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAyB1F"}

package/dist/api/utils/async-caller-proxy.js

@@ -1,36 +0,0 @@
-const resolveCallerPath = (root, path) => {
-    let current = root;
-    for (const key of path) {
-        if (!current || (typeof current !== 'object' && typeof current !== 'function')) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-};
-export function createAsyncCallerProxy(getCaller) {
-    const callProcedure = async (path, args) => {
-        const caller = await getCaller();
-        const proc = resolveCallerPath(caller, path);
-        if (typeof proc !== 'function') {
-            throw new Error(`tRPC procedure not found: ${path.join('.')}`);
-        }
-        return proc(...args);
-    };
-    const createCallerProxy = (path = []) => {
-        const proxyTarget = (...args) => callProcedure(path, args);
-        return new Proxy(proxyTarget, {
-            get(_target, prop) {
-                if (prop === 'then')
-                    return undefined;
-                if (typeof prop !== 'string')
-                    return undefined;
-                return createCallerProxy([...path, prop]);
-            },
-            apply(_target, _thisArg, args) {
-                return callProcedure(path, args);
-            },
-        });
-    };
-    return createCallerProxy();
-}

package/dist/api/utils/lazy-caller-proxy.d.ts

@@ -1,2 +0,0 @@
-export declare function createLazyCallerProxy<TCaller>(getCaller: () => Promise<TCaller>): TCaller;
-//# sourceMappingURL=lazy-caller-proxy.d.ts.map

package/dist/api/utils/lazy-caller-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy-caller-proxy.d.ts","sourceRoot":"","sources":["../../../src/api/utils/lazy-caller-proxy.ts"],"names":[],"mappings":"AAWA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAyBzF"}

package/dist/api/utils/lazy-caller-proxy.js

@@ -1,36 +0,0 @@
-const resolveCallerPath = (root, path) => {
-    let current = root;
-    for (const key of path) {
-        if (!current || (typeof current !== 'object' && typeof current !== 'function')) {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-};
-export function createLazyCallerProxy(getCaller) {
-    const callProcedure = async (path, args) => {
-        const caller = await getCaller();
-        const proc = resolveCallerPath(caller, path);
-        if (typeof proc !== 'function') {
-            throw new Error(`tRPC procedure not found: ${path.join('.')}`);
-        }
-        return proc(...args);
-    };
-    const createCallerProxy = (path = []) => {
-        const proxyTarget = (...args) => callProcedure(path, args);
-        return new Proxy(proxyTarget, {
-            get(_target, prop) {
-                if (prop === 'then')
-                    return undefined;
-                if (typeof prop !== 'string')
-                    return undefined;
-                return createCallerProxy([...path, prop]);
-            },
-            apply(_target, _thisArg, args) {
-                return callProcedure(path, args);
-            },
-        });
-    };
-    return createCallerProxy();
-}

package/dist/api/utils/router-types.d.ts

@@ -1,7 +0,0 @@
-import type { AnyRouter } from '@trpc/server';
-import type { CoreRouters } from '../root.js';
-export type RouterRecord = Record<string, AnyRouter>;
-export type NonConflictingRouterRecord<TUser extends RouterRecord> = Extract<keyof TUser, keyof CoreRouters> extends never ? TUser : {
-    [K in keyof TUser]: K extends keyof CoreRouters ? never : TUser[K];
-};
-//# sourceMappingURL=router-types.d.ts.map

package/dist/api/utils/router-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router-types.d.ts","sourceRoot":"","sources":["../../../src/api/utils/router-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEpD,MAAM,MAAM,0BAA0B,CAAC,KAAK,SAAS,YAAY,IAC7D,OAAO,CAAC,MAAM,KAAK,EAAE,MAAM,WAAW,CAAC,SAAS,KAAK,GAC/C,KAAK,GACL;KACK,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC,SAAS,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;CACrE,CAAA"}

package/dist/auth/axios/axiosInstance.d.ts

@@ -1,2 +0,0 @@
-export declare const axiosPrivate: import("axios").AxiosInstance;
-//# sourceMappingURL=axiosInstance.d.ts.map

package/dist/auth/axios/axiosInstance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axiosInstance.d.ts","sourceRoot":"","sources":["../../../src/auth/axios/axiosInstance.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,+BAMvB,CAAA"}

package/dist/auth/axios/axiosInstance.js

@@ -1,8 +0,0 @@
-import axios from 'axios';
-export const axiosPrivate = axios.create({
-    baseURL: '/api',
-    headers: {
-        'Content-Type': 'application/json',
-    },
-    withCredentials: true,
-});

package/dist/auth/hooks/useAxiosPrivate.d.ts

@@ -1,5 +0,0 @@
-declare const useAxiosPrivate: (options?: {
-    refreshTokenOn?: 401 | 404;
-}) => import("axios").AxiosInstance;
-export default useAxiosPrivate;
-//# sourceMappingURL=useAxiosPrivate.d.ts.map

package/dist/auth/hooks/useAxiosPrivate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAxiosPrivate.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/useAxiosPrivate.tsx"],"names":[],"mappings":"AAMA,QAAA,MAAM,eAAe,GAAI,UAAU;IAAE,cAAc,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,kCAgFhE,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/auth/hooks/useAxiosPrivate.js

@@ -1,74 +0,0 @@
-import { axiosPrivate } from '../axios/axiosInstance.js';
-import { useEffect } from 'react';
-import useRefreshToken from './useRefreshToken.js';
-import axios from 'axios';
-import { getCsrfToken } from '../react.js';
-const useAxiosPrivate = (options) => {
-    const refresh = useRefreshToken();
-    const { refreshTokenOn = 401 } = options || {};
-    useEffect(() => {
-        /**
-         * Add a request interceptor
-         */
-        const requestIntercept = axiosPrivate.interceptors.request.use(
-        /**
-         * Do something before request is sent
-         * @param config The request config object
-         */
-        async (config) => {
-            if (config.method && ['post', 'put', 'delete'].includes(config.method.toLowerCase())) {
-                /**
-                 * If the request is a POST, PUT, or DELETE request, the XSRF-TOKEN header is added to the request.
-                 */
-                config.headers['x-csrf-token'] = await getCsrfToken();
-            }
-            /**
-             * Return the config object
-             */
-            return config;
-        }, (error) => Promise.reject(error));
-        /**
-         * This is the response interceptor
-         */
-        const responseIntercept = axiosPrivate.interceptors.response.use((response) => response, // Do nothing if the request is successful,
-        async (error) => {
-            // If the access token has expired, refresh it and retry the request
-            const prevRequest = error?.config; // The request that caused the error (the one that returned 401) is saved in the error object
-            if (error?.response?.status === refreshTokenOn && !prevRequest?.sent) {
-                // If the error is 401 and the request hasn't been sent before
-                prevRequest.sent = true; // Prevent infinite loops
-                const refreshStatus = await refresh(); // Refresh the access token cookie
-                if (refreshStatus === false)
-                    return Promise.reject(error); // If the refresh failed, reject the promise
-                // NOTICE: This is needed to send the request as multipart form data,
-                //  because resending the request with axios resets the Content-Type to application/json for some reason
-                // Use transformRequest to set Content-Type and include boundary for multipart form data
-                prevRequest.headers['Content-Type'] = 'multipart/form-data';
-                prevRequest.transformRequest = [
-                    (data, headers) => {
-                        // If the request data is FormData, set the boundary
-                        if (data instanceof FormData) {
-                            // @ts-ignore
-                            headers['Content-Type'] += `; boundary=${data._boundary}`;
-                        }
-                        return data;
-                    },
-                    ...axios.defaults.transformRequest, // Keep the default transformRequest functions
-                ];
-                return axiosPrivate(prevRequest); // The request that returned 401 is retried with the new access token
-            }
-            return Promise.reject(error);
-        });
-        // Remove the interceptors when the component unmounts
-        // This is needed to prevent memory leaks
-        return () => {
-            // Eject the interceptors
-            axiosPrivate.interceptors.request.eject(requestIntercept);
-            axiosPrivate.interceptors.response.eject(responseIntercept);
-        };
-    }, [
-    /*auth, refresh*/
-    ]);
-    return axiosPrivate;
-};
-export default useAxiosPrivate;

package/dist/auth/trpc.d.ts

@@ -1,6 +0,0 @@
-import type { TRPCLink } from '@trpc/client';
-/**
- * tRPC link that refreshes the token if it's expired
- */
-export declare const refreshTokenLink: () => TRPCLink<any>;
-//# sourceMappingURL=trpc.d.ts.map

package/dist/auth/trpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/auth/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAK5C;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,QAAQ,CAAC,GAAG,CA6E/C,CAAA"}