@appconda/nextjs 1.0.76 → 1.0.78

package/dist/actions/actionClient.d.ts

@@ -2,3 +2,9 @@ export declare const actionClient: import("next-safe-action").SafeActionClient<s
     formErrors: string[];
     fieldErrors: {};
 }, readonly []>;
+export declare const authenticatedActionClient: import("next-safe-action").SafeActionClient<string, undefined, undefined, unknown, {
+    user: any;
+}, undefined, undefined, undefined, readonly [], {
+    formErrors: string[];
+    fieldErrors: {};
+}, readonly []>;

package/dist/actions/actionClient.js

@@ -1,4 +1,7 @@
+import { getServerSession } from "next-auth";
 import { DEFAULT_SERVER_ERROR_MESSAGE, createSafeActionClient } from "next-safe-action";
+import { authOptions } from "./authOptions";
+import { AuthenticationError, AuthorizationError } from "../lib/errors";
 export const actionClient = createSafeActionClient({
     handleServerError(e) {
         /* if (
@@ -17,19 +20,15 @@ export const actionClient = createSafeActionClient({
         return DEFAULT_SERVER_ERROR_MESSAGE;
     },
 });
-/* export const authenticatedActionClient = actionClient.use(async ({ next }) => {
-  const session = await getServerSession(authOptions);
-  if (!session?.user) {
-    throw new AuthenticationError("Not authenticated");
-  }
-
-  const userId = session.user.id;
-
-  const user = await getUser(userId);
-  if (!user) {
-    throw new AuthorizationError("User not found");
-  }
-
-  return next({ ctx: { user } });
+export const authenticatedActionClient = actionClient.use(async ({ next }) => {
+    const session = await getServerSession(authOptions);
+    if (!session?.user) {
+        throw new AuthenticationError("Not authenticated");
+    }
+    const userId = session.user.id;
+    const user = await getUser(userId);
+    if (!user) {
+        throw new AuthorizationError("User not found");
+    }
+    return next({ ctx: { user } });
 });
- */ 

package/dist/actions/authOptions.d.ts

@@ -0,0 +1,6 @@
+import type { NextAuthOptions } from "next-auth";
+export declare function signIn({ userName, password }: {
+    userName: string;
+    password: string;
+}): Promise<import("../modules/account/types").Session>;
+export declare const authOptions: NextAuthOptions;

package/dist/actions/authOptions.js

@@ -0,0 +1,215 @@
+import CredentialsProvider from "next-auth/providers/credentials";
+import { cookies } from "next/headers";
+import { getAppcondaClient } from "../getAppcondaClient";
+import { Account } from "../modules/account/service";
+import { env } from "../lib/env";
+import { getSDKForCurrentUser } from "../getSDKForCurrentUser";
+import { Query } from "../query";
+export async function signIn({ userName, password }) {
+    const adminClient = await getAppcondaClient();
+    const account = new Account(adminClient);
+    const session = await account.createEmailPasswordSession(userName, password);
+    const c = await cookies();
+    c.set('a_session', session.secret, {
+        path: "/",
+        httpOnly: true,
+        sameSite: "strict",
+        secure: true,
+    });
+    return session;
+}
+export const authOptions = {
+    providers: [
+        CredentialsProvider({
+            id: "credentials",
+            // The name to display on the sign in form (e.g. "Sign in with...")
+            name: "Credentials",
+            // The credentials is used to generate a suitable form on the sign in page.
+            // You can specify whatever fields you are expecting to be submitted.
+            // e.g. domain, username, password, 2FA token, etc.
+            // You can pass any HTML attribute to the <input> tag through the object.
+            credentials: {
+                email: {
+                    label: "Email Address",
+                    type: "email",
+                    placeholder: "Your email address",
+                },
+                password: {
+                    label: "Password",
+                    type: "password",
+                    placeholder: "Your password",
+                },
+                totpCode: { label: "Two-factor Code", type: "input", placeholder: "Code from authenticator app" },
+                backupCode: { label: "Backup Code", type: "input", placeholder: "Two-factor backup code" },
+            },
+            async authorize(credentials, _req) {
+                let user;
+                const appcondaSession = await signIn({ userName: credentials?.email, password: credentials?.password });
+                console.log(credentials);
+                /*  try {
+                   user = await prisma.user.findUnique({
+                     where: {
+                       email: credentials?.email,
+                     },
+                   });
+                 } catch (e) {
+                   console.error(e);
+                   throw Error("Internal server error. Please try again later");
+                 }
+                 if (!user || !credentials) {
+                   throw new Error("Invalid credentials");
+                 }
+                 if (!user.password) {
+                   throw new Error("Invalid credentials");
+                 }
+         
+                 const isValid = await verifyPassword(credentials.password, user.password);
+         
+                 if (!isValid) {
+                   throw new Error("Invalid credentials");
+                 }
+         
+                 if (user.twoFactorEnabled && credentials.backupCode) {
+                   if (!ENCRYPTION_KEY) {
+                     console.error("Missing encryption key; cannot proceed with backup code login.");
+                     throw new Error("Internal Server Error");
+                   }
+         
+                   if (!user.backupCodes) throw new Error("No backup codes found");
+         
+                   const backupCodes = JSON.parse(symmetricDecrypt(user.backupCodes, ENCRYPTION_KEY));
+         
+                   // check if user-supplied code matches one
+                   const index = backupCodes.indexOf(credentials.backupCode.replaceAll("-", ""));
+                   if (index === -1) throw new Error("Invalid backup code");
+         
+                   // delete verified backup code and re-encrypt remaining
+                   backupCodes[index] = null;
+                   await prisma.user.update({
+                     where: {
+                       id: user.id,
+                     },
+                     data: {
+                       backupCodes: symmetricEncrypt(JSON.stringify(backupCodes), ENCRYPTION_KEY),
+                     },
+                   });
+                 } else if (user.twoFactorEnabled) {
+                   if (!credentials.totpCode) {
+                     throw new Error("second factor required");
+                   }
+         
+                   if (!user.twoFactorSecret) {
+                     throw new Error("Internal Server Error");
+                   }
+         
+                   if (!ENCRYPTION_KEY) {
+                     throw new Error("Internal Server Error");
+                   }
+         
+                   const secret = symmetricDecrypt(user.twoFactorSecret, ENCRYPTION_KEY);
+                   if (secret.length !== 32) {
+                     throw new Error("Internal Server Error");
+                   }
+         
+                   const isValidToken = (await import("./totp")).totpAuthenticatorCheck(credentials.totpCode, secret);
+                   if (!isValidToken) {
+                     throw new Error("Invalid second factor code");
+                   }
+                 } */
+                console.log("asafdf");
+                return {
+                    id: appcondaSession.userId,
+                    email: appcondaSession.providerUid,
+                    emailVerified: true,
+                    imageUrl: "",
+                };
+            },
+        }),
+        CredentialsProvider({
+            id: "token",
+            // The name to display on the sign in form (e.g. "Sign in with...")
+            name: "Token",
+            // The credentials is used to generate a suitable form on the sign in page.
+            // You can specify whatever fields you are expecting to be submitted.
+            // e.g. domain, username, password, 2FA token, etc.
+            // You can pass any HTML attribute to the <input> tag through the object.
+            credentials: {
+                token: {
+                    label: "Verification Token",
+                    type: "string",
+                },
+            },
+            async authorize(credentials, _req) {
+                let user;
+                /*  try {
+                   if (!credentials?.token) {
+                     throw new Error("Token not found");
+                   }
+                   const { id } = await verifyToken(credentials?.token);
+                   user = await prisma.user.findUnique({
+                     where: {
+                       id: id,
+                     },
+                   });
+                 } catch (e) {
+                   console.error(e);
+                   throw new Error("Either a user does not match the provided token or the token is invalid");
+                 }
+         
+                 if (!user) {
+                   throw new Error("Either a user does not match the provided token or the token is invalid");
+                 }
+         
+                 if (user.emailVerified) {
+                   throw new Error("Email already verified");
+                 }
+         
+                 user = await updateUser(user.id, { emailVerified: new Date() }); */
+                return user || null;
+            },
+        }),
+        // Conditionally add enterprise SSO providers
+        ...(env.ENTERPRISE_LICENSE_KEY ? [] : []),
+    ],
+    callbacks: {
+        async jwt({ token }) {
+            const { users } = await getSDKForCurrentUser();
+            const userList = await users.list([Query.equal("email", token.email)]);
+            const user = userList.users[0] ?? {};
+            /*  const existingUser = await getUserByEmail(token?.email!);
+       
+             if (!existingUser) {
+               return token;
+             } */
+            return {
+                ...token,
+                profile: { id: user.$id, ...user },
+            };
+        },
+        async session({ session, token }) {
+            // @ts-expect-error
+            session.user.id = token?.id;
+            // @ts-expect-error
+            session.user = token.profile;
+            return session;
+        },
+        async signIn({ user, account }) {
+            /*   if (account?.provider === "credentials" || account?.provider === "token") {
+                // check if user's email is verified or not
+                if (!user.emailVerified && !EMAIL_VERIFICATION_DISABLED) {
+                  throw new Error("Email Verification is Pending");
+                }
+                return true;
+              }
+              if (ENTERPRISE_LICENSE_KEY) {
+                return handleSSOCallback({ user, account });
+              } */
+            return true;
+        },
+    },
+    pages: {
+        signIn: "/auth/login",
+        signOut: "/auth/logout",
+        error: "/auth/login", // Error code passed in query string as ?error=
+    },
+};

package/dist/lib/env.d.ts

@@ -1,5 +1,7 @@
+import 'server-only';
 export declare const env: Readonly<{
     APPCONDA_ENDPOINT: string;
     APPCONDA_CLIENT_ENDPOINT: string;
     _SERVICE_TOKEN: string;
+    ENTERPRISE_LICENSE_KEY: string;
 }>;

package/dist/lib/env.js

@@ -1,5 +1,6 @@
 import { createEnv } from "@t3-oss/env-nextjs";
 import { z } from "zod";
+import 'server-only';
 export const env = createEnv({
     /*
      * Serverside Environment variables, not available on the client.
@@ -9,6 +10,7 @@ export const env = createEnv({
         APPCONDA_ENDPOINT: z.string(),
         APPCONDA_CLIENT_ENDPOINT: z.string(),
         _SERVICE_TOKEN: z.string(),
+        ENTERPRISE_LICENSE_KEY: z.string(),
         /* AI_AZURE_LLM_API_KEY: z.string().optional(),
         AI_AZURE_EMBEDDINGS_DEPLOYMENT_ID: z.string().optional(),
         AI_AZURE_LLM_DEPLOYMENT_ID: z.string().optional(),
@@ -113,6 +115,7 @@ export const env = createEnv({
         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,
     },
 });
 console.log(env);

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,75 @@
+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, };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@appconda/nextjs",
   "homepage": "https://appconda.io/support",
   "description": "Appconda is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "license": "BSD-3-Clause",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,6 +25,7 @@
   "unpkg": "dist/iife/sdk.js",
   "dependencies": {
     "next": "^15.2.3",
+    "next-auth": "^4.24.11",
     "next-safe-action": "^7.10.4",
     "node-fetch-native-with-agent": "^1.7.2",
     "server-only": "^0.0.1",

package/src/actions/actionClient.ts

@@ -1,6 +1,8 @@
 
-
+import { getServerSession } from "next-auth";
 import { DEFAULT_SERVER_ERROR_MESSAGE, createSafeActionClient } from "next-safe-action";
+import { authOptions } from "./authOptions";
+import { AuthenticationError, AuthorizationError } from "../lib/errors";
 
 
 
@@ -24,7 +26,7 @@ export const actionClient = createSafeActionClient({
   },
 });
 
-/* export const authenticatedActionClient = actionClient.use(async ({ next }) => {
+export const authenticatedActionClient = actionClient.use(async ({ next }) => {
   const session = await getServerSession(authOptions);
   if (!session?.user) {
     throw new AuthenticationError("Not authenticated");
@@ -39,4 +41,3 @@ export const actionClient = createSafeActionClient({
 
   return next({ ctx: { user } });
 });
- */

package/src/actions/authOptions.ts

@@ -0,0 +1,237 @@
+import type {  NextAuthOptions } from "next-auth";
+import CredentialsProvider from "next-auth/providers/credentials";
+import { cookies } from "next/headers";
+import { getAppcondaClient } from "../getAppcondaClient";
+import { Account } from "../modules/account/service";
+import { env } from "../lib/env";
+import { getSDKForCurrentUser } from "../getSDKForCurrentUser";
+import { Query } from "../query";
+
+
+export async function signIn({ userName, password }: { userName: string, password: string }) {
+
+
+  const adminClient = await getAppcondaClient();
+
+  const account = new Account(adminClient);
+
+  const session = await account.createEmailPasswordSession(userName, password);
+
+  const c = await cookies();
+
+  c.set('a_session', session.secret, {
+    path: "/",
+    httpOnly: true,
+    sameSite: "strict",
+    secure: true,
+  });
+
+  return session;
+
+}
+
+export const authOptions: NextAuthOptions = {
+  providers: [
+    CredentialsProvider({
+      id: "credentials",
+      // The name to display on the sign in form (e.g. "Sign in with...")
+      name: "Credentials",
+      // The credentials is used to generate a suitable form on the sign in page.
+      // You can specify whatever fields you are expecting to be submitted.
+      // e.g. domain, username, password, 2FA token, etc.
+      // You can pass any HTML attribute to the <input> tag through the object.
+      credentials: {
+        email: {
+          label: "Email Address",
+          type: "email",
+          placeholder: "Your email address",
+        },
+        password: {
+          label: "Password",
+          type: "password",
+          placeholder: "Your password",
+        },
+        totpCode: { label: "Two-factor Code", type: "input", placeholder: "Code from authenticator app" },
+        backupCode: { label: "Backup Code", type: "input", placeholder: "Two-factor backup code" },
+      },
+      async authorize(credentials, _req) {
+        let user;
+        const appcondaSession = await signIn({ userName: credentials?.email as string, password: credentials?.password as string });
+
+        console.log(credentials);
+        /*  try {
+           user = await prisma.user.findUnique({
+             where: {
+               email: credentials?.email,
+             },
+           });
+         } catch (e) {
+           console.error(e);
+           throw Error("Internal server error. Please try again later");
+         }
+         if (!user || !credentials) {
+           throw new Error("Invalid credentials");
+         }
+         if (!user.password) {
+           throw new Error("Invalid credentials");
+         }
+ 
+         const isValid = await verifyPassword(credentials.password, user.password);
+ 
+         if (!isValid) {
+           throw new Error("Invalid credentials");
+         }
+ 
+         if (user.twoFactorEnabled && credentials.backupCode) {
+           if (!ENCRYPTION_KEY) {
+             console.error("Missing encryption key; cannot proceed with backup code login.");
+             throw new Error("Internal Server Error");
+           }
+ 
+           if (!user.backupCodes) throw new Error("No backup codes found");
+ 
+           const backupCodes = JSON.parse(symmetricDecrypt(user.backupCodes, ENCRYPTION_KEY));
+ 
+           // check if user-supplied code matches one
+           const index = backupCodes.indexOf(credentials.backupCode.replaceAll("-", ""));
+           if (index === -1) throw new Error("Invalid backup code");
+ 
+           // delete verified backup code and re-encrypt remaining
+           backupCodes[index] = null;
+           await prisma.user.update({
+             where: {
+               id: user.id,
+             },
+             data: {
+               backupCodes: symmetricEncrypt(JSON.stringify(backupCodes), ENCRYPTION_KEY),
+             },
+           });
+         } else if (user.twoFactorEnabled) {
+           if (!credentials.totpCode) {
+             throw new Error("second factor required");
+           }
+ 
+           if (!user.twoFactorSecret) {
+             throw new Error("Internal Server Error");
+           }
+ 
+           if (!ENCRYPTION_KEY) {
+             throw new Error("Internal Server Error");
+           }
+ 
+           const secret = symmetricDecrypt(user.twoFactorSecret, ENCRYPTION_KEY);
+           if (secret.length !== 32) {
+             throw new Error("Internal Server Error");
+           }
+ 
+           const isValidToken = (await import("./totp")).totpAuthenticatorCheck(credentials.totpCode, secret);
+           if (!isValidToken) {
+             throw new Error("Invalid second factor code");
+           }
+         } */
+
+        console.log("asafdf")
+
+        return {
+          id: appcondaSession.userId,
+          email: appcondaSession.providerUid,
+          emailVerified: true,
+          imageUrl: "",
+        };
+      },
+    }),
+    CredentialsProvider({
+      id: "token",
+      // The name to display on the sign in form (e.g. "Sign in with...")
+      name: "Token",
+      // The credentials is used to generate a suitable form on the sign in page.
+      // You can specify whatever fields you are expecting to be submitted.
+      // e.g. domain, username, password, 2FA token, etc.
+      // You can pass any HTML attribute to the <input> tag through the object.
+      credentials: {
+        token: {
+          label: "Verification Token",
+          type: "string",
+        },
+      },
+      async authorize(credentials, _req) {
+
+        let user;
+        /*  try {
+           if (!credentials?.token) {
+             throw new Error("Token not found");
+           }
+           const { id } = await verifyToken(credentials?.token);
+           user = await prisma.user.findUnique({
+             where: {
+               id: id,
+             },
+           });
+         } catch (e) {
+           console.error(e);
+           throw new Error("Either a user does not match the provided token or the token is invalid");
+         }
+ 
+         if (!user) {
+           throw new Error("Either a user does not match the provided token or the token is invalid");
+         }
+ 
+         if (user.emailVerified) {
+           throw new Error("Email already verified");
+         }
+ 
+         user = await updateUser(user.id, { emailVerified: new Date() }); */
+
+        return user || null;
+      },
+    }),
+    // Conditionally add enterprise SSO providers
+    ...(env.ENTERPRISE_LICENSE_KEY ? [] : []),
+  ],
+  callbacks: {
+    async jwt({ token }) {
+
+      const { users } = await getSDKForCurrentUser();
+      const userList = await users.list([Query.equal("email", token.email!)])
+    
+      const user = userList.users[0] ?? {};
+
+      /*  const existingUser = await getUserByEmail(token?.email!);
+ 
+       if (!existingUser) {
+         return token;
+       } */
+
+      return {
+        ...token,
+        profile: { id: user.$id, ...user },
+      };
+    },
+    async session({ session, token }) {
+      // @ts-expect-error
+      session.user.id = token?.id;
+      // @ts-expect-error
+      session.user = token.profile;
+
+      return session;
+    },
+    async signIn({ user, account }: { user: any; account: Account | null }) {
+      /*   if (account?.provider === "credentials" || account?.provider === "token") {
+          // check if user's email is verified or not
+          if (!user.emailVerified && !EMAIL_VERIFICATION_DISABLED) {
+            throw new Error("Email Verification is Pending");
+          }
+          return true;
+        }
+        if (ENTERPRISE_LICENSE_KEY) {
+          return handleSSOCallback({ user, account });
+        } */
+      return true;
+    },
+  },
+  pages: {
+    signIn: "/auth/login",
+    signOut: "/auth/logout",
+    error: "/auth/login", // Error code passed in query string as ?error=
+  },
+};

package/src/lib/env.ts

@@ -1,5 +1,6 @@
 import { createEnv } from "@t3-oss/env-nextjs";
 import { z } from "zod";
+import 'server-only';
 
 export const env = createEnv({
   /*
@@ -10,6 +11,7 @@ export const env = createEnv({
     APPCONDA_ENDPOINT: z.string(),
     APPCONDA_CLIENT_ENDPOINT: z.string(),
     _SERVICE_TOKEN: z.string(),
+    ENTERPRISE_LICENSE_KEY: z.string(),
     /* AI_AZURE_LLM_API_KEY: z.string().optional(),
     AI_AZURE_EMBEDDINGS_DEPLOYMENT_ID: z.string().optional(),
     AI_AZURE_LLM_DEPLOYMENT_ID: z.string().optional(),
@@ -115,6 +117,7 @@ export const env = createEnv({
     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,
   },
 });
 

package/src/lib/errors.ts

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