@appconda/nextjs 1.0.384 → 1.0.386

package/dist/actions/_authOptions.d.ts

@@ -0,0 +1,5 @@
+export declare function signIn({ userName, password }: {
+    userName: string;
+    password: string;
+}): Promise<import("../modules/account/types").Session>;
+export declare const authOptions: () => any;

package/dist/actions/_authOptions.js

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

package/dist/actions/authOptions.d.ts

@@ -1,5 +1,5 @@
 export declare function signIn({ userName, password }: {
     userName: string;
     password: string;
-}): Promise<import("../modules/account/types").Session>;
+}): Promise<any>;
 export declare const authOptions: () => any;

package/dist/actions/authOptions.js

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

package/dist/getAppcondaClient.d.ts

@@ -1,2 +1,3 @@
 import { Client } from "./client";
 export declare function getAppcondaClient(): Promise<Client>;
+export declare function getAppcondaClientSync(): Client;

package/dist/getAppcondaClient.js

@@ -41,4 +41,31 @@ export async function getAppcondaClient() {
         .setProject('console');
     return adminClient;
 }
-//# sourceMappingURL=data:application/json;base64,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
+export function getAppcondaClientSync() {
+    let url;
+    if (getEnv().APPCONDA_ENDPOINT) {
+        url = getEnv().APPCONDA_ENDPOINT;
+    }
+    else if (typeof window !== 'undefined') {
+        const hostInfo = getPortAndHostname(window.location.href);
+        if (hostInfo.port) {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}:${hostInfo.port}/v1`;
+        }
+        else {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}/v1`;
+        }
+    }
+    else {
+        url = getEnv().APPCONDA_ENDPOINT || 'http://appconda/v1';
+    }
+    /*  if (ApplicationConfig.Port == null) {
+         url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}:${ApplicationConfig.Port}/v1`
+     } else {
+           url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}/v1`
+     }  */
+    const adminClient = new Client()
+        .setEndpoint(url) // Your API Endpoint
+        .setProject('console');
+    return adminClient;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/accounv1/action.d.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod';
-import { _CreateUserSchema, GetUserByIdSchema, RegisterUserSchema, UpdateUserVerifyTokenSchema } from './schema';
+import { _CreateUserSchema, CredentialLoginSchema, GetUserByIdSchema, RegisterUserSchema, TokenLoginSchema, UpdateUserVerifyTokenSchema } from './schema';
 import { TUser } from './types';
 export declare function CreateUser(parsedInput: z.infer<typeof _CreateUserSchema>): Promise<TUser>;
 export declare function RegisterUser(parsedInput: z.infer<typeof RegisterUserSchema>): Promise<TUser>;
 export declare function GetUserById(parsedInput: z.infer<typeof GetUserByIdSchema>): Promise<TUser>;
 export declare function UpdateUserVerifyToken(parsedInput: z.infer<typeof UpdateUserVerifyTokenSchema>): Promise<TUser>;
+export declare function CredentialLogin(parsedInput: z.infer<typeof CredentialLoginSchema>): Promise<TUser>;
+export declare function TokenLogin(parsedInput: z.infer<typeof TokenLoginSchema>): Promise<TUser>;