@appconda/sdk 1.0.194 → 1.0.410

package/dist/lib/env.js

@@ -0,0 +1,137 @@
+import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+export const getEnv = (() => {
+    let env = null;
+    return () => {
+        if (env == null) {
+            env = createEnv({
+                /*
+                 * Serverside Environment variables, not available on the client.
+                 * Will throw if you access these variables on the client.
+                 */
+                server: {
+                    APPCONDA_ENDPOINT: z.string().default('http://localhost/v1'),
+                    APPCONDA_CLIENT_ENDPOINT: z.string().default('http://localhost/v1'),
+                    _SERVICE_TOKEN: z.string().default('7c5e77c31363c1b4b36b8940001326a0cc813fab4f48df839813dfbd7b386dc5'),
+                    ENTERPRISE_LICENSE_KEY: z.string().default('none'),
+                    NEXTAUTH_SECRET: z.string().min(1).default('f9b89c6a0f8c4e2d3a59b76d58d1a4e5f7c6b2a9e3d4f1c0b8a6d7e9f5c2b3a1'),
+                    ENCRYPTION_KEY: z.string().length(64).or(z.string().length(32)).default('51570cb4caa6c1f5f80e6e57a32efb397e9220434532697c94c8f821a7dd1851'),
+                    CRON_SECRET: z.string().min(10).default('51570cb4caa6c1f5f80e6e57a32efb397e9220434532697c94c8f821a7dd1851'),
+                    _ADMIN_DOMAIN: z.string().optional(),
+                    /* AI_AZURE_LLM_API_KEY: z.string().optional(),
+                    AI_AZURE_EMBEDDINGS_DEPLOYMENT_ID: z.string().optional(),
+                    AI_AZURE_LLM_DEPLOYMENT_ID: z.string().optional(),
+                    AI_AZURE_EMBEDDINGS_RESSOURCE_NAME: z.string().optional(),
+                    AI_AZURE_LLM_RESSOURCE_NAME: z.string().optional(),
+                    AIRTABLE_CLIENT_ID: z.string().optional(),
+                    AZUREAD_CLIENT_ID: z.string().optional(),
+                    AZUREAD_CLIENT_SECRET: z.string().optional(),
+                    AZUREAD_TENANT_ID: z.string().optional(),
+                    CRON_SECRET: z.string().min(10),
+                    CUSTOMER_IO_API_KEY: z.string().optional(),
+                    CUSTOMER_IO_SITE_ID: z.string().optional(),
+                    DATABASE_URL: z.string().url(),
+                    DEBUG: z.enum(["1", "0"]).optional(),
+                    DEFAULT_ORGANIZATION_ID: z.string().optional(),
+                    DEFAULT_ORGANIZATION_ROLE: z.enum(["owner", "manager", "member", "billing"]).optional(),
+                    E2E_TESTING: z.enum(["1", "0"]).optional(),
+                    EMAIL_AUTH_DISABLED: z.enum(["1", "0"]).optional(),
+                    EMAIL_VERIFICATION_DISABLED: z.enum(["1", "0"]).optional(),
+                   
+                    ENTERPRISE_LICENSE_KEY: z.string().optional(),
+                    FORMBRICKS_ENCRYPTION_KEY: z.string().length(24).or(z.string().length(0)).optional(),
+                    GITHUB_ID: z.string().optional(),
+                    GITHUB_SECRET: z.string().optional(),
+                    GOOGLE_CLIENT_ID: z.string().optional(),
+                    GOOGLE_CLIENT_SECRET: z.string().optional(),
+                    GOOGLE_SHEETS_CLIENT_ID: z.string().optional(),
+                    GOOGLE_SHEETS_CLIENT_SECRET: z.string().optional(),
+                    GOOGLE_SHEETS_REDIRECT_URL: z.string().optional(),
+                    HTTP_PROXY: z.string().url().optional(),
+                    HTTPS_PROXY: z.string().url().optional(),
+                    IMPRINT_URL: z
+                      .string()
+                      .url()
+                      .optional()
+                      .or(z.string().refine((str) => str === "")),
+                    IMPRINT_ADDRESS: z.string().optional(),
+                    INVITE_DISABLED: z.enum(["1", "0"]).optional(),
+                    INTERCOM_SECRET_KEY: z.string().optional(),
+                    IS_FORMBRICKS_CLOUD: z.enum(["1", "0"]).optional(),
+                    MAIL_FROM: z.string().email().optional(),
+                    
+                    NOTION_OAUTH_CLIENT_ID: z.string().optional(),
+                    NOTION_OAUTH_CLIENT_SECRET: z.string().optional(),
+                    OIDC_CLIENT_ID: z.string().optional(),
+                    OIDC_CLIENT_SECRET: z.string().optional(),
+                    OIDC_DISPLAY_NAME: z.string().optional(),
+                    OIDC_ISSUER: z.string().optional(),
+                    OIDC_SIGNING_ALGORITHM: z.string().optional(),
+                    OPENTELEMETRY_LISTENER_URL: z.string().optional(),
+                    REDIS_URL: z.string().optional(),
+                    REDIS_HTTP_URL: z.string().optional(),
+                    PASSWORD_RESET_DISABLED: z.enum(["1", "0"]).optional(),
+                    PRIVACY_URL: z
+                      .string()
+                      .url()
+                      .optional()
+                      .or(z.string().refine((str) => str === "")),
+                    RATE_LIMITING_DISABLED: z.enum(["1", "0"]).optional(),
+                    S3_ACCESS_KEY: z.string().optional(),
+                    S3_BUCKET_NAME: z.string().optional(),
+                    S3_REGION: z.string().optional(),
+                    S3_SECRET_KEY: z.string().optional(),
+                    S3_ENDPOINT_URL: z.string().optional(),
+                    S3_FORCE_PATH_STYLE: z.enum(["1", "0"]).optional(),
+                    SHORT_URL_BASE: z.string().url().optional().or(z.string().length(0)),
+                    SIGNUP_DISABLED: z.enum(["1", "0"]).optional(),
+                    SLACK_CLIENT_ID: z.string().optional(),
+                    SLACK_CLIENT_SECRET: z.string().optional(),
+                    SMTP_HOST: z.string().min(1).optional(),
+                    SMTP_PORT: z.string().min(1).optional(),
+                    SMTP_SECURE_ENABLED: z.enum(["1", "0"]).optional(),
+                    SMTP_USER: z.string().min(1).optional(),
+                    SMTP_PASSWORD: z.string().min(1).optional(),
+                    SMTP_AUTHENTICATED: z.enum(["1", "0"]).optional(),
+                    SMTP_REJECT_UNAUTHORIZED_TLS: z.enum(["1", "0"]).optional(),
+                    STRIPE_SECRET_KEY: z.string().optional(),
+                    STRIPE_WEBHOOK_SECRET: z.string().optional(),
+                    TELEMETRY_DISABLED: z.enum(["1", "0"]).optional(),
+                    TERMS_URL: z
+                      .string()
+                      .url()
+                      .optional()
+                      .or(z.string().refine((str) => str === "")),
+                    TURNSTILE_SECRET_KEY: z.string().optional(),
+                    UPLOADS_DIR: z.string().min(1).optional(),
+                    VERCEL_URL: z.string().optional(),
+                  
+                    ADMIN_URL: z.string().url().optional(),
+                    UNSPLASH_ACCESS_KEY: z.string().optional(),
+                    LANGFUSE_SECRET_KEY: z.string().optional(),
+                    LANGFUSE_PUBLIC_KEY: z.string().optional(),
+                    LANGFUSE_BASEURL: z.string().optional(), */
+                },
+                /*
+                 * Due to how Next.js bundles environment variables on Edge and Client,
+                 * we need to manually destructure them to make sure all are included in bundle.
+                 *
+                 * 💡 You'll get type errors if not all variables from `server` & `client` are included here.
+                 */
+                runtimeEnv: {
+                    APPCONDA_ENDPOINT: process.env.APPCONDA_ENDPOINT,
+                    APPCONDA_CLIENT_ENDPOINT: process.env.APPCONDA_CLIENT_ENDPOINT,
+                    _SERVICE_TOKEN: process.env._SERVICE_TOKEN,
+                    ENTERPRISE_LICENSE_KEY: process.env.ENTERPRISE_LICENSE_KEY,
+                    NEXTAUTH_SECRET: process.env.NEXTAUTH_SECRET,
+                    ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
+                    CRON_SECRET: process.env.CRON_SECRET,
+                    _ADMIN_DOMAIN: process.env._ADMIN_DOMAIN,
+                },
+            });
+            console.log(env);
+        }
+        return env;
+    };
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/lib/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE;IACxB,IAAI,GAAG,GAAQ,IAAI,CAAC;IACpB,OAAO,GAAG,EAAE;QACR,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;YACd,GAAG,GAAG,SAAS,CAAC;gBACZ;;;mBAGG;gBACH,MAAM,EAAE;oBACJ,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,qBAAqB,CAAC;oBAC5D,wBAAwB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,qBAAqB,CAAC;oBACnE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,kEAAkE,CAAC;oBACtG,sBAAsB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;oBAClD,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,kEAAkE,CAAC;oBAC9G,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,kEAAkE,CAAC;oBAC3I,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,kEAAkE,CAAC;oBAC3G,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;oBACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DA4F2C;iBAC9C;gBAED;;;;;mBAKG;gBACH,UAAU,EAAE;oBACR,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB;oBAChD,wBAAwB,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB;oBAC9D,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;oBAC1C,sBAAsB,EAAE,OAAO,CAAC,GAAG,CAAC,sBAAsB;oBAC1D,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;oBAC5C,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;oBAC1C,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW;oBACpC,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa;iBAC3C;aACJ,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrB,CAAC;QAED,OAAO,GAAG,CAAC;IAEf,CAAC,CAAC;AACN,CAAC,CAAC,EAAE,CAAC","sourcesContent":["import { createEnv } from \"@t3-oss/env-nextjs\";\nimport { z } from \"zod\";\n\n\nexport const getEnv = (() => {\n    let env: any = null;\n    return () => {\n        if (env == null) {\n            env = createEnv({\n                /*\n                 * Serverside Environment variables, not available on the client.\n                 * Will throw if you access these variables on the client.\n                 */\n                server: {\n                    APPCONDA_ENDPOINT: z.string().default('http://localhost/v1'),\n                    APPCONDA_CLIENT_ENDPOINT: z.string().default('http://localhost/v1'),\n                    _SERVICE_TOKEN: z.string().default('7c5e77c31363c1b4b36b8940001326a0cc813fab4f48df839813dfbd7b386dc5'),\n                    ENTERPRISE_LICENSE_KEY: z.string().default('none'),\n                    NEXTAUTH_SECRET: z.string().min(1).default('f9b89c6a0f8c4e2d3a59b76d58d1a4e5f7c6b2a9e3d4f1c0b8a6d7e9f5c2b3a1'),\n                    ENCRYPTION_KEY: z.string().length(64).or(z.string().length(32)).default('51570cb4caa6c1f5f80e6e57a32efb397e9220434532697c94c8f821a7dd1851'),\n                    CRON_SECRET: z.string().min(10).default('51570cb4caa6c1f5f80e6e57a32efb397e9220434532697c94c8f821a7dd1851'),\n                    _ADMIN_DOMAIN: z.string().optional(),\n                    /* AI_AZURE_LLM_API_KEY: z.string().optional(),\n                    AI_AZURE_EMBEDDINGS_DEPLOYMENT_ID: z.string().optional(),\n                    AI_AZURE_LLM_DEPLOYMENT_ID: z.string().optional(),\n                    AI_AZURE_EMBEDDINGS_RESSOURCE_NAME: z.string().optional(),\n                    AI_AZURE_LLM_RESSOURCE_NAME: z.string().optional(),\n                    AIRTABLE_CLIENT_ID: z.string().optional(),\n                    AZUREAD_CLIENT_ID: z.string().optional(),\n                    AZUREAD_CLIENT_SECRET: z.string().optional(),\n                    AZUREAD_TENANT_ID: z.string().optional(),\n                    CRON_SECRET: z.string().min(10),\n                    CUSTOMER_IO_API_KEY: z.string().optional(),\n                    CUSTOMER_IO_SITE_ID: z.string().optional(),\n                    DATABASE_URL: z.string().url(),\n                    DEBUG: z.enum([\"1\", \"0\"]).optional(),\n                    DEFAULT_ORGANIZATION_ID: z.string().optional(),\n                    DEFAULT_ORGANIZATION_ROLE: z.enum([\"owner\", \"manager\", \"member\", \"billing\"]).optional(),\n                    E2E_TESTING: z.enum([\"1\", \"0\"]).optional(),\n                    EMAIL_AUTH_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    EMAIL_VERIFICATION_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                   \n                    ENTERPRISE_LICENSE_KEY: z.string().optional(),\n                    FORMBRICKS_ENCRYPTION_KEY: z.string().length(24).or(z.string().length(0)).optional(),\n                    GITHUB_ID: z.string().optional(),\n                    GITHUB_SECRET: z.string().optional(),\n                    GOOGLE_CLIENT_ID: z.string().optional(),\n                    GOOGLE_CLIENT_SECRET: z.string().optional(),\n                    GOOGLE_SHEETS_CLIENT_ID: z.string().optional(),\n                    GOOGLE_SHEETS_CLIENT_SECRET: z.string().optional(),\n                    GOOGLE_SHEETS_REDIRECT_URL: z.string().optional(),\n                    HTTP_PROXY: z.string().url().optional(),\n                    HTTPS_PROXY: z.string().url().optional(),\n                    IMPRINT_URL: z\n                      .string()\n                      .url()\n                      .optional()\n                      .or(z.string().refine((str) => str === \"\")),\n                    IMPRINT_ADDRESS: z.string().optional(),\n                    INVITE_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    INTERCOM_SECRET_KEY: z.string().optional(),\n                    IS_FORMBRICKS_CLOUD: z.enum([\"1\", \"0\"]).optional(),\n                    MAIL_FROM: z.string().email().optional(),\n                    \n                    NOTION_OAUTH_CLIENT_ID: z.string().optional(),\n                    NOTION_OAUTH_CLIENT_SECRET: z.string().optional(),\n                    OIDC_CLIENT_ID: z.string().optional(),\n                    OIDC_CLIENT_SECRET: z.string().optional(),\n                    OIDC_DISPLAY_NAME: z.string().optional(),\n                    OIDC_ISSUER: z.string().optional(),\n                    OIDC_SIGNING_ALGORITHM: z.string().optional(),\n                    OPENTELEMETRY_LISTENER_URL: z.string().optional(),\n                    REDIS_URL: z.string().optional(),\n                    REDIS_HTTP_URL: z.string().optional(),\n                    PASSWORD_RESET_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    PRIVACY_URL: z\n                      .string()\n                      .url()\n                      .optional()\n                      .or(z.string().refine((str) => str === \"\")),\n                    RATE_LIMITING_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    S3_ACCESS_KEY: z.string().optional(),\n                    S3_BUCKET_NAME: z.string().optional(),\n                    S3_REGION: z.string().optional(),\n                    S3_SECRET_KEY: z.string().optional(),\n                    S3_ENDPOINT_URL: z.string().optional(),\n                    S3_FORCE_PATH_STYLE: z.enum([\"1\", \"0\"]).optional(),\n                    SHORT_URL_BASE: z.string().url().optional().or(z.string().length(0)),\n                    SIGNUP_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    SLACK_CLIENT_ID: z.string().optional(),\n                    SLACK_CLIENT_SECRET: z.string().optional(),\n                    SMTP_HOST: z.string().min(1).optional(),\n                    SMTP_PORT: z.string().min(1).optional(),\n                    SMTP_SECURE_ENABLED: z.enum([\"1\", \"0\"]).optional(),\n                    SMTP_USER: z.string().min(1).optional(),\n                    SMTP_PASSWORD: z.string().min(1).optional(),\n                    SMTP_AUTHENTICATED: z.enum([\"1\", \"0\"]).optional(),\n                    SMTP_REJECT_UNAUTHORIZED_TLS: z.enum([\"1\", \"0\"]).optional(),\n                    STRIPE_SECRET_KEY: z.string().optional(),\n                    STRIPE_WEBHOOK_SECRET: z.string().optional(),\n                    TELEMETRY_DISABLED: z.enum([\"1\", \"0\"]).optional(),\n                    TERMS_URL: z\n                      .string()\n                      .url()\n                      .optional()\n                      .or(z.string().refine((str) => str === \"\")),\n                    TURNSTILE_SECRET_KEY: z.string().optional(),\n                    UPLOADS_DIR: z.string().min(1).optional(),\n                    VERCEL_URL: z.string().optional(),\n                  \n                    ADMIN_URL: z.string().url().optional(),\n                    UNSPLASH_ACCESS_KEY: z.string().optional(),\n                    LANGFUSE_SECRET_KEY: z.string().optional(),\n                    LANGFUSE_PUBLIC_KEY: z.string().optional(),\n                    LANGFUSE_BASEURL: z.string().optional(), */\n                },\n\n                /*\n                 * Due to how Next.js bundles environment variables on Edge and Client,\n                 * we need to manually destructure them to make sure all are included in bundle.\n                 *\n                 * 💡 You'll get type errors if not all variables from `server` & `client` are included here.\n                 */\n                runtimeEnv: {\n                    APPCONDA_ENDPOINT: process.env.APPCONDA_ENDPOINT,\n                    APPCONDA_CLIENT_ENDPOINT: process.env.APPCONDA_CLIENT_ENDPOINT,\n                    _SERVICE_TOKEN: process.env._SERVICE_TOKEN,\n                    ENTERPRISE_LICENSE_KEY: process.env.ENTERPRISE_LICENSE_KEY,\n                    NEXTAUTH_SECRET: process.env.NEXTAUTH_SECRET,\n                    ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,\n                    CRON_SECRET: process.env.CRON_SECRET,\n                    _ADMIN_DOMAIN: process.env._ADMIN_DOMAIN,\n                },\n            });\n            console.log(env);\n        }\n\n        return env;\n\n    };\n})();\n\n\n\n\n"]}

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<readonly [z.ZodAny], null>, 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,79 @@
+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({
+    input: [z.any()],
+    output: 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.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIiXX0=

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"]}

package/dist/lib/types.d.ts

@@ -0,0 +1,5 @@
+export interface ActionResult<T> {
+    data?: T;
+    serverError?: string;
+    validationError?: string;
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJcblxuZXhwb3J0IGludGVyZmFjZSBBY3Rpb25SZXN1bHQ8VD4ge1xuICAgIGRhdGE/OiBUO1xuICAgIHNlcnZlckVycm9yPzogc3RyaW5nO1xuICAgIHZhbGlkYXRpb25FcnJvcj86IHN0cmluZztcbn0iXX0=