@appconda/nextjs 1.0.115 → 1.0.117

package/dist/lib/errors.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+declare class ResourceNotFoundError extends Error {
+    statusCode: number;
+    resourceId: string | null;
+    resourceType: string;
+    constructor(resource: string, id: string | null);
+}
+declare class InvalidInputError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class ValidationError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class UnknownError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class DatabaseError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class UniqueConstraintError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class ForeignKeyConstraintError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class OperationNotAllowedError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class AuthenticationError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+declare class AuthorizationError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+interface NetworkError {
+    code: "network_error";
+    message: string;
+    status: number;
+    url: URL;
+    responseMessage?: string;
+    details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+}
+interface ForbiddenError {
+    code: "forbidden";
+    message: string;
+    status: number;
+    url: URL;
+    responseMessage?: string;
+    details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+}
+export declare const ZErrorHandler: z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>;
+export { ResourceNotFoundError, InvalidInputError, ValidationError, DatabaseError, UniqueConstraintError, UnknownError, ForeignKeyConstraintError, OperationNotAllowedError, AuthenticationError, AuthorizationError, };
+export type { NetworkError, ForbiddenError };
+export interface ApiErrorResponse {
+    code: "not_found" | "gone" | "bad_request" | "internal_server_error" | "unauthorized" | "method_not_allowed" | "not_authenticated" | "forbidden" | "network_error";
+    message: string;
+    status: number;
+    url: URL;
+    details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+    responseMessage?: string;
+}

package/dist/lib/errors.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+class ResourceNotFoundError extends Error {
+    constructor(resource, id) {
+        super(id ? `${resource} with ID ${id} not found` : `${resource} not found`);
+        this.statusCode = 404;
+        this.name = "ResourceNotFoundError";
+        this.resourceType = resource;
+        this.resourceId = id;
+    }
+}
+class InvalidInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 400;
+        this.name = "InvalidInputError";
+    }
+}
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 400;
+        this.name = "ValidationError";
+    }
+}
+class UnknownError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 500;
+        this.name = "UnknownError";
+    }
+}
+class DatabaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 500;
+        this.name = "DatabaseError";
+    }
+}
+class UniqueConstraintError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 409;
+        this.name = "UniqueConstraintError";
+    }
+}
+class ForeignKeyConstraintError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 409;
+        this.name = "ForeignKeyConstraintError";
+    }
+}
+class OperationNotAllowedError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 403;
+        this.name = "OperationNotAllowedError";
+    }
+}
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 401;
+        this.name = "AuthenticationError";
+    }
+}
+class AuthorizationError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 403;
+        this.name = "AuthorizationError";
+    }
+}
+export const ZErrorHandler = z.function().args(z.any()).returns(z.void());
+export { ResourceNotFoundError, InvalidInputError, ValidationError, DatabaseError, UniqueConstraintError, UnknownError, ForeignKeyConstraintError, OperationNotAllowedError, AuthenticationError, AuthorizationError, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./jwt";
+export * from "./env";

package/dist/lib/index.js

@@ -0,0 +1,3 @@
+export * from "./jwt";
+export * from "./env";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsT0FBTyxDQUFDO0FBQ3RCLGNBQWMsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vand0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnZcIjsiXX0=

package/dist/lib/jwt.d.ts

@@ -0,0 +1,12 @@
+import { JwtPayload } from "jsonwebtoken";
+export declare const createToken: (userId: string, userEmail: string, options?: {}) => string;
+export declare const createTokenForLinkSurvey: (surveyId: string, userEmail: string) => string;
+export declare const createEmailToken: (email: string) => string;
+export declare const getEmailFromEmailToken: (token: string) => string;
+export declare const createInviteToken: (inviteId: string, email: string, options?: {}) => string;
+export declare const verifyTokenForLinkSurvey: (token: string, surveyId: string) => string | null;
+export declare const verifyToken: (token: string) => Promise<JwtPayload>;
+export declare const verifyInviteToken: (token: string) => {
+    inviteId: string;
+    email: string;
+};

package/dist/lib/jwt.js

@@ -0,0 +1,103 @@
+import jwt from "jsonwebtoken";
+import { symmetricDecrypt, symmetricEncrypt } from "./crypto";
+import { getEnv } from "./env";
+export const createToken = (userId, userEmail, options = {}) => {
+    const encryptedUserId = symmetricEncrypt(userId, getEnv().ENCRYPTION_KEY);
+    return jwt.sign({ id: encryptedUserId }, getEnv().NEXTAUTH_SECRET + userEmail, options);
+};
+export const createTokenForLinkSurvey = (surveyId, userEmail) => {
+    const encryptedEmail = symmetricEncrypt(userEmail, getEnv().ENCRYPTION_KEY);
+    return jwt.sign({ email: encryptedEmail }, getEnv().NEXTAUTH_SECRET + surveyId);
+};
+export const createEmailToken = (email) => {
+    const encryptedEmail = symmetricEncrypt(email, getEnv().ENCRYPTION_KEY);
+    return jwt.sign({ email: encryptedEmail }, getEnv().NEXTAUTH_SECRET);
+};
+export const getEmailFromEmailToken = (token) => {
+    const payload = jwt.verify(token, getEnv().NEXTAUTH_SECRET);
+    try {
+        // Try to decrypt first (for newer tokens)
+        const decryptedEmail = symmetricDecrypt(payload.email, getEnv().ENCRYPTION_KEY);
+        return decryptedEmail;
+    }
+    catch {
+        // If decryption fails, return the original email (for older tokens)
+        return payload.email;
+    }
+};
+export const createInviteToken = (inviteId, email, options = {}) => {
+    const encryptedInviteId = symmetricEncrypt(inviteId, getEnv().ENCRYPTION_KEY);
+    const encryptedEmail = symmetricEncrypt(email, getEnv().ENCRYPTION_KEY);
+    return jwt.sign({ inviteId: encryptedInviteId, email: encryptedEmail }, getEnv().NEXTAUTH_SECRET, options);
+};
+export const verifyTokenForLinkSurvey = (token, surveyId) => {
+    try {
+        const { email } = jwt.verify(token, getEnv().NEXTAUTH_SECRET + surveyId);
+        try {
+            // Try to decrypt first (for newer tokens)
+            const decryptedEmail = symmetricDecrypt(email, getEnv().ENCRYPTION_KEY);
+            return decryptedEmail;
+        }
+        catch {
+            // If decryption fails, return the original email (for older tokens)
+            return email;
+        }
+    }
+    catch (err) {
+        return null;
+    }
+};
+export const verifyToken = async (token) => {
+    // First decode to get the ID
+    const decoded = jwt.decode(token);
+    const payload = decoded;
+    const { id } = payload;
+    if (!id) {
+        throw new Error("Token missing required field: id");
+    }
+    // Try to decrypt the ID (for newer tokens), if it fails use the ID as-is (for older tokens)
+    let decryptedId;
+    try {
+        decryptedId = symmetricDecrypt(id, getEnv().ENCRYPTION_KEY);
+    }
+    catch {
+        decryptedId = id;
+    }
+    // If no email provided, look up the user
+    const foundUser = null; /* await prisma.user.findUnique({
+      where: { id: decryptedId },
+    }); */
+    if (!foundUser) {
+        throw new Error("User not found");
+    }
+    const userEmail = foundUser.email;
+    return { id: decryptedId, email: userEmail };
+};
+export const verifyInviteToken = (token) => {
+    try {
+        const decoded = jwt.decode(token);
+        const payload = decoded;
+        const { inviteId, email } = payload;
+        let decryptedInviteId;
+        let decryptedEmail;
+        try {
+            // Try to decrypt first (for newer tokens)
+            decryptedInviteId = symmetricDecrypt(inviteId, getEnv().ENCRYPTION_KEY);
+            decryptedEmail = symmetricDecrypt(email, getEnv().ENCRYPTION_KEY);
+        }
+        catch {
+            // If decryption fails, use original values (for older tokens)
+            decryptedInviteId = inviteId;
+            decryptedEmail = email;
+        }
+        return {
+            inviteId: decryptedInviteId,
+            email: decryptedEmail,
+        };
+    }
+    catch (error) {
+        console.error(`Error verifying invite token: ${error}`);
+        throw new Error("Invalid or expired invite token");
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwt.js","sourceRoot":"","sources":["../../src/lib/jwt.ts"],"names":[],"mappings":"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","sourcesContent":["import jwt, { JwtPayload } from \"jsonwebtoken\";\nimport { symmetricDecrypt, symmetricEncrypt } from \"./crypto\";\nimport { getEnv } from \"./env\";\n\nexport const createToken = (userId: string, userEmail: string, options = {}): string => {\n  const encryptedUserId = symmetricEncrypt(userId, getEnv().ENCRYPTION_KEY);\n  return jwt.sign({ id: encryptedUserId }, getEnv().NEXTAUTH_SECRET + userEmail, options);\n};\nexport const createTokenForLinkSurvey = (surveyId: string, userEmail: string): string => {\n  const encryptedEmail = symmetricEncrypt(userEmail, getEnv().ENCRYPTION_KEY);\n  return jwt.sign({ email: encryptedEmail }, getEnv().NEXTAUTH_SECRET + surveyId);\n};\n\nexport const createEmailToken = (email: string): string => {\n  const encryptedEmail = symmetricEncrypt(email, getEnv().ENCRYPTION_KEY);\n  return jwt.sign({ email: encryptedEmail }, getEnv().NEXTAUTH_SECRET);\n};\n\nexport const getEmailFromEmailToken = (token: string): string => {\n  const payload = jwt.verify(token, getEnv().NEXTAUTH_SECRET) as JwtPayload;\n  try {\n    // Try to decrypt first (for newer tokens)\n    const decryptedEmail = symmetricDecrypt(payload.email, getEnv().ENCRYPTION_KEY);\n    return decryptedEmail;\n  } catch {\n    // If decryption fails, return the original email (for older tokens)\n    return payload.email;\n  }\n};\n\nexport const createInviteToken = (inviteId: string, email: string, options = {}): string => {\n  const encryptedInviteId = symmetricEncrypt(inviteId, getEnv().ENCRYPTION_KEY);\n  const encryptedEmail = symmetricEncrypt(email, getEnv().ENCRYPTION_KEY);\n  return jwt.sign({ inviteId: encryptedInviteId, email: encryptedEmail }, getEnv().NEXTAUTH_SECRET, options);\n};\n\nexport const verifyTokenForLinkSurvey = (token: string, surveyId: string): string | null => {\n  try {\n    const { email } = jwt.verify(token, getEnv().NEXTAUTH_SECRET + surveyId) as JwtPayload;\n    try {\n      // Try to decrypt first (for newer tokens)\n      const decryptedEmail = symmetricDecrypt(email, getEnv().ENCRYPTION_KEY);\n      return decryptedEmail;\n    } catch {\n      // If decryption fails, return the original email (for older tokens)\n      return email;\n    }\n  } catch (err) {\n    return null;\n  }\n};\n\nexport const verifyToken = async (token: string): Promise<JwtPayload> => {\n  // First decode to get the ID\n  const decoded = jwt.decode(token);\n  const payload: JwtPayload = decoded as JwtPayload;\n\n  const { id } = payload;\n  if (!id) {\n    throw new Error(\"Token missing required field: id\");\n  }\n\n  // Try to decrypt the ID (for newer tokens), if it fails use the ID as-is (for older tokens)\n  let decryptedId: string;\n  try {\n    decryptedId = symmetricDecrypt(id, getEnv().ENCRYPTION_KEY);\n  } catch {\n    decryptedId = id;\n  }\n\n  // If no email provided, look up the user\n  const foundUser: any = null;/* await prisma.user.findUnique({\n    where: { id: decryptedId },\n  }); */\n\n  if (!foundUser) {\n    throw new Error(\"User not found\");\n  }\n\n  const userEmail = foundUser.email;\n\n  return { id: decryptedId, email: userEmail };\n};\n\nexport const verifyInviteToken = (token: string): { inviteId: string; email: string } => {\n  try {\n    const decoded = jwt.decode(token);\n    const payload: JwtPayload = decoded as JwtPayload;\n\n    const { inviteId, email } = payload;\n\n    let decryptedInviteId: string;\n    let decryptedEmail: string;\n\n    try {\n      // Try to decrypt first (for newer tokens)\n      decryptedInviteId = symmetricDecrypt(inviteId, getEnv().ENCRYPTION_KEY);\n      decryptedEmail = symmetricDecrypt(email, getEnv().ENCRYPTION_KEY);\n    } catch {\n      // If decryption fails, use original values (for older tokens)\n      decryptedInviteId = inviteId;\n      decryptedEmail = email;\n    }\n\n    return {\n      inviteId: decryptedInviteId,\n      email: decryptedEmail,\n    };\n  } catch (error) {\n    console.error(`Error verifying invite token: ${error}`);\n    throw new Error(\"Invalid or expired invite token\");\n  }\n};\n"]}