nextjs-cms 0.0.1 → 0.5.1

package/dist/api/routers/gallery.js

@@ -0,0 +1,62 @@
+import { privateProcedure, router } from '../trpc';
+import * as z from 'zod';
+import fs from 'fs';
+import path from 'path';
+import { SectionFactory } from '../../core/factories';
+import { TRPCError } from '@trpc/server';
+import getString from '../../translations';
+import { db } from '../../db/client';
+import { sql } from 'drizzle-orm';
+import { MysqlTableChecker } from '../../core/db';
+import { getCMSConfig } from '../../core/config';
+export const galleryRouter = router({
+    deletePhoto: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        photoName: z.string(),
+        referenceId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const uploadsFolder = getCMSConfig().files.upload.uploadPath;
+        /**
+         * Get the section information
+         */
+        const sectionConfig = await SectionFactory.getSectionForAdmin({
+            name: input.sectionName,
+            admin: {
+                id: ctx.session.user.id,
+            },
+        });
+        if (sectionConfig?.name !== input.sectionName) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('sectionNotFound'),
+            });
+        }
+        const section = sectionConfig?.build();
+        /**
+         * Delete the photo from the database
+         */
+        if (section.gallery?.db.tableName) {
+            const columns = await MysqlTableChecker.getColumns(section.gallery.db.tableName);
+            if (columns.includes(section.gallery.db.photoNameField) &&
+                columns.includes(section.gallery.db.referenceIdentifierField)) {
+                await db.execute(sql `DELETE FROM ${sql.raw(section.gallery.db.tableName)} WHERE ${sql.raw(section.gallery.db.photoNameField)} = ${input.photoName} AND ${sql.raw(section.gallery.db.referenceIdentifierField)} = ${input.referenceId}`);
+            }
+        }
+        /**
+         * Delete the photo from disk
+         */
+        try {
+            await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, input.photoName));
+            /**
+             * TODO: Thumbs are not being deleted, it throws an error that they are being used by nodejs. Fix this
+             */
+            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, input.photoName));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return true;
+    }),
+});

package/dist/api/routers/googleAnalytics.d.ts

@@ -0,0 +1,31 @@
+export declare const googleAnalyticsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    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;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    test: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=googleAnalytics.d.ts.map

package/dist/api/routers/googleAnalytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"googleAnalytics.d.ts","sourceRoot":"","sources":["../../../src/api/routers/googleAnalytics.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIhC,CAAA"}

package/dist/api/routers/googleAnalytics.js

@@ -0,0 +1,7 @@
+import { privateProcedure, router } from '../trpc';
+// import { BetaAnalyticsDataClient } from '@google-analytics/data'
+export const googleAnalyticsRouter = router({
+    test: privateProcedure.query(async ({ ctx }) => {
+        return true;
+    }),
+});

package/dist/api/routers/hasItemsSection.d.ts

@@ -0,0 +1,140 @@
+import * as z from 'zod';
+export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.core.$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;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listItems: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+            page?: number | undefined;
+            q?: string | undefined;
+        };
+        output: {
+            error: {
+                message: string;
+            };
+            section?: undefined;
+            items?: undefined;
+            totalCount?: undefined;
+        } | {
+            section: {
+                hasSearch: boolean;
+                name: string;
+                title: string;
+            };
+            items: {
+                id: string | number;
+                headingTitle: string;
+                coverPhoto: string | null;
+                createdAt: string;
+                createdBy: string;
+                permission: number;
+            }[];
+            totalCount: any;
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+    newItem: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+        };
+        output: {
+            error: {
+                message: any;
+            };
+            section?: undefined;
+            inputGroups?: undefined;
+        } | {
+            section: import("../..").HasItemsSection;
+            inputGroups: {
+                groupId: number;
+                groupTitle: string;
+                groupOrder: number;
+                inputs: {
+                    type: import("../../core/types").FieldType;
+                    name: string;
+                    label: string;
+                    required: boolean;
+                    conditionalFields: import("../../core/types").ConditionalField[];
+                    readonly: boolean;
+                    defaultValue: any;
+                    value: any;
+                }[];
+            }[] | undefined;
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+    editItem: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+            sectionItemId: string | number;
+        };
+        output: {
+            error: {
+                message: string;
+            };
+            section?: undefined;
+            inputGroups?: undefined;
+            gallery?: undefined;
+        } | {
+            section: import("../..").HasItemsSection;
+            inputGroups: {
+                groupId: number;
+                groupTitle: string;
+                groupOrder: number;
+                inputs: {
+                    type: import("../../core/types").FieldType;
+                    name: string;
+                    label: string;
+                    required: boolean;
+                    conditionalFields: import("../../core/types").ConditionalField[];
+                    readonly: boolean;
+                    defaultValue: any;
+                    value: any;
+                }[];
+            }[] | undefined;
+            gallery: {
+                referenceId: string;
+                photo: string;
+                meta: any;
+            }[];
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+    deleteItem: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sectionName: string;
+            sectionItemId: string | number;
+        };
+        output: true | {
+            error: {
+                message: string;
+            };
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=hasItemsSection.d.ts.map

package/dist/api/routers/hasItemsSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasItemsSection.d.ts","sourceRoot":"","sources":["../../../src/api/routers/hasItemsSection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqChC,CAAA"}

package/dist/api/routers/hasItemsSection.js

@@ -0,0 +1,34 @@
+import { privateProcedure, router } from '../trpc';
+import * as z from 'zod';
+import { createEditPage, createNewPage, deleteSectionItem, getBrowsePage } from '../lib/serverActions';
+export const hasItemsSectionRouter = router({
+    listItems: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        page: z.number().optional(),
+        q: z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await getBrowsePage(ctx.session, input.sectionName, input.page, input.q);
+    }),
+    newItem: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await createNewPage(ctx.session, input.sectionName);
+    }),
+    editItem: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        sectionItemId: z.number().or(z.string()),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await createEditPage(ctx.session, input.sectionName, input.sectionItemId);
+    }),
+    deleteItem: privateProcedure
+        .input(z.object({ sectionName: z.string(), sectionItemId: z.number().or(z.string()) }))
+        .mutation(async ({ ctx, input }) => {
+        return await deleteSectionItem(ctx.session, input.sectionName, input.sectionItemId);
+    }),
+});

package/dist/api/routers/navigation.d.ts

@@ -0,0 +1,52 @@
+export declare const navRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    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;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getSidebar: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            fixed_sections: {
+                title: string;
+                path: string;
+                icon: string;
+            }[];
+            cat_sections: {
+                title: string;
+                path: string;
+                icon: string | undefined;
+            }[];
+            has_items_sections: {
+                title: string;
+                path: string;
+                icon: string | undefined;
+            }[];
+            simple_sections: {
+                title: string;
+                path: string;
+                icon: string | undefined;
+            }[];
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/api/routers/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/api/routers/navigation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQpB,CAAA"}

package/dist/api/routers/navigation.js

@@ -0,0 +1,11 @@
+import { privateProcedure, router } from '../trpc';
+import { getSidebar } from '../lib/serverActions';
+export const navRouter = router({
+    getSidebar: privateProcedure.query(async ({ ctx }) => {
+        /**
+         * TODO: This function is always returning the same fixed sections for all admins.
+         * We need to include the fixed sections in the privileges logic.
+         */
+        return await getSidebar(ctx.session);
+    }),
+});

package/dist/api/routers/simpleSection.d.ts

@@ -0,0 +1,58 @@
+import * as z from 'zod';
+export declare const simpleSectionRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.core.$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;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    create: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+        };
+        output: {
+            error: {
+                message: string;
+            };
+            section?: undefined;
+            inputGroups?: undefined;
+        } | {
+            section: import("../..").SimpleSection;
+            inputGroups: {
+                groupId: number;
+                groupTitle: string;
+                groupOrder: number;
+                inputs: {
+                    type: import("../../core/types").FieldType;
+                    name: string;
+                    label: string;
+                    required: boolean;
+                    conditionalFields: import("../../core/types").ConditionalField[];
+                    readonly: boolean;
+                    defaultValue: any;
+                    value: any;
+                }[];
+            }[] | undefined;
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=simpleSection.d.ts.map

package/dist/api/routers/simpleSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleSection.d.ts","sourceRoot":"","sources":["../../../src/api/routers/simpleSection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAU9B,CAAA"}

package/dist/api/routers/simpleSection.js

@@ -0,0 +1,12 @@
+import { privateProcedure, router } from '../trpc';
+import * as z from 'zod';
+import { createSimpleSectionPage } from '../lib/serverActions';
+export const simpleSectionRouter = router({
+    create: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await createSimpleSectionPage(ctx.session, input.sectionName);
+    }),
+});

package/dist/api/trpc.d.ts

@@ -0,0 +1,107 @@
+import superjson from 'superjson';
+import type { NextRequest } from 'next/server';
+/**
+ * Creates context for an incoming request
+ * @link https://trpc.io/docs/v11/context
+ */
+export declare const createTRPCContext: (opts: {
+    req: NextRequest;
+}) => Promise<{
+    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema")> & {
+        $client: import("mysql2/promise").Pool;
+    };
+    session: import("..").Session | null;
+    opts: {
+        headers: Headers;
+    };
+}>;
+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: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    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: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("..").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    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<{
+    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema")> & {
+        $client: import("mysql2/promise").Pool;
+    };
+    session: import("..").Session | null;
+    opts: {
+        headers: Headers;
+    };
+}, 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<{
+    db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../db/schema")> & {
+        $client: import("mysql2/promise").Pool;
+    };
+    session: import("..").Session | null;
+    opts: {
+        headers: Headers;
+    };
+}, object, {
+    session: {
+        user: import("..").User;
+    };
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+//# sourceMappingURL=trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/api/trpc.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,WAAW,CAAA;AAEjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAI9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,MAAM;IAAE,GAAG,EAAE,WAAW,CAAA;CAAE;;;;;;;;EAWjE,CAAA;AAID,eAAO,MAAM,WAAW;;;CAGvB,CAAA;AAiCD;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;EAAwB,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;EAAW,CAAA;AAE9B;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;yLAAc,CAAA;AAE1C;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;yKAAsC,CAAA"}

package/dist/api/trpc.js

@@ -0,0 +1,72 @@
+import { initTRPC, TRPCError } from '@trpc/server';
+import superjson from 'superjson';
+import { ZodError } from 'zod';
+import auth from '../auth';
+import { db } from '../db/client';
+/**
+ * Creates context for an incoming request
+ * @link https://trpc.io/docs/v11/context
+ */
+export const createTRPCContext = async (opts) => {
+    const session = await auth();
+    const headers = opts.req.headers;
+    return {
+        db,
+        session,
+        opts: {
+            headers,
+        },
+    };
+};
+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
+    },*/
+});
+const isAuthedMiddleware = t.middleware(async ({ ctx, next }) => {
+    if (!ctx.session || !ctx.session.user)
+        throw new TRPCError({ code: 'UNAUTHORIZED', message: 'No token provided' });
+    return next({
+        /*ctx: {
+            user: user,
+            headers: ctx.opts.headers,
+        },*/
+        ctx: {
+            // infers the `session` as non-nullable
+            session: { ...ctx.session, user: ctx.session.user },
+        },
+    });
+});
+/**
+ * Create a server-side caller
+ * @see https://trpc.io/docs/server/server-side-calls
+ */
+export const createCallerFactory = t.createCallerFactory;
+/**
+ * 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);

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

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

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

@@ -0,0 +1 @@
+{"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

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

package/dist/auth/csrf.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Creates a cookie with the value 'token|hash',
+ * where 'token' is the CSRF token and 'hash' is a hash made of the token and
+ * the secret, and the two values are joined by a pipe '|'. By storing the
+ * value and the hash of the value (with the secret used as a salt) we can
+ * verify the cookie was set by the server and not by a malicious attacker.
+ *
+ * For more details, see the following OWASP links:
+ * https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#double-submit-cookie
+ * https://owasp.org/www-chapter-london/assets/slides/David_Johansson-Double_Defeat_of_Double-Submit_Cookie.pdf
+ */
+export declare function createCSRFToken(cookieValue?: string): Promise<{
+    csrfToken: string;
+    cookie?: undefined;
+} | {
+    cookie: string;
+    csrfToken: string;
+}>;
+/**
+ * This function is used to validate the CSRF token in POST, PUT, DELETE requests (or any request that changes data)
+ * @param cookieValue
+ * @param bodyValue
+ */
+export declare function validateCSRFToken({ cookieValue, bodyValue }: {
+    cookieValue?: string;
+    bodyValue?: string;
+}): Promise<boolean>;
+export declare function randomString(size: number): string;
+export declare function createHash(message: string): Promise<string>;
+//# sourceMappingURL=csrf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csrf.d.ts","sourceRoot":"","sources":["../../src/auth/csrf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM;;;;;;GAoCzD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,oBAe/G;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAKxC;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,mBAO/C"}