@appconda/nextjs 1.0.384 → 1.0.386

package/src/actions/authOptions.ts

@@ -1,11 +1,12 @@
-import type { NextAuthOptions } from "next-auth";
+import type { Account, 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 { getAppcondaClient, getAppcondaClientSync } from "../getAppcondaClient";
+
 import { getEnv } from "../lib/env";
 import { getSDKForCurrentUser } from "../getSDKForCurrentUser";
 import { Query } from "../query";
+import { AccountService, TUser } from "../modules";
 
 /* const getEnv = () => {
   return {
@@ -16,6 +17,10 @@ import { Query } from "../query";
   };
 }; */
 
+const ENCRYPTION_KEY='51570cb4caa6c1f5f80e6e57a32efb397e9220434532697c94c8f821a7dd1951';
+const ENTERPRISE_LICENSE_KEY = '';
+const EMAIL_VERIFICATION_DISABLED = false;
+
 export async function signIn({ userName, password }: { userName: string, password: string }) {
   const adminClient = await getAppcondaClient();
 
@@ -36,8 +41,12 @@ export async function signIn({ userName, password }: { userName: string, passwor
 
 }
 
+
+
 export const authOptions = (() => {
   let options : any= null;
+  const adminClient =  getAppcondaClientSync();
+  const accountService = new AccountService(adminClient);
 
   return () => {
     if (options == null) {
@@ -66,90 +75,9 @@ 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 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: "",
-              };
+              const session = await accountService.CredentialLogin(credentials as any);
+            
+              return session;
             },
           }),
           CredentialsProvider({
@@ -167,79 +95,48 @@ 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 }: { 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;
+          async signIn({ user, account }: { user: TUser; account: 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");
               }
-              if (ENTERPRISE_LICENSE_KEY) {
-                return handleSSOCallback({ user, account });
-              } */
+              return true;
+            }
+            /* if (ENTERPRISE_LICENSE_KEY) {
+              return handleSSOCallback({ user, account });
+            } */
             return true;
           },
         },

package/src/getAppcondaClient.ts

@@ -42,4 +42,33 @@ export async function getAppcondaClient() {
 
     return adminClient
 
+}
+
+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
+
 }

package/src/modules/accounv1/action.ts

@@ -2,10 +2,9 @@
 
 import { z } from 'zod';
 import { AppcondaException } from '../../client';
-import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
-import { _CreateUserSchema, GetUserByIdSchema, RegisterUserSchema, UpdateUserVerifyTokenSchema } from './schema';
-import { TUser } from './types';
 import { getSDKForService } from '../../getSDKForService';
+import { _CreateUserSchema, CredentialLoginSchema, GetUserByIdSchema, RegisterUserSchema, TokenLoginSchema, UpdateUserVerifyTokenSchema } from './schema';
+import { TUser } from './types';
 
 export async function CreateUser(parsedInput: z.infer<typeof _CreateUserSchema>): Promise<TUser> {
     try {
@@ -67,3 +66,32 @@ export async function UpdateUserVerifyToken(parsedInput: z.infer<typeof UpdateUs
     }
 }
 
+export async function CredentialLogin(parsedInput: z.infer<typeof CredentialLoginSchema>): Promise<TUser> {
+    try {
+        const { accounts } = await getSDKForService();
+        //@ts-ignore
+        const app = await accounts.CredentialLogin(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function TokenLogin(parsedInput: z.infer<typeof TokenLoginSchema>): Promise<TUser> {
+    try {
+        const { accounts } = await getSDKForService();
+        //@ts-ignore
+        const app = await accounts.TokenLogin(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}

package/src/modules/accounv1/schema.ts

@@ -15,13 +15,14 @@ export const _CreateUserSchema = z.object({
 export const RegisterUserSchema = z.object({
     email: z.string(),
     password: z.string(),
-    firstName: z.string(),
-    lastName: z.string(),
-    active: z.boolean().optional(),
-    githubId: z.string().optional(),
-    googleId: z.string().optional(),
-    avatarURL: z.string().optional(),
-    locale: z.string().optional()
+    name: z.string(),
+    inviteToken: z.string().optional(),
+    userLocale: z.string().optional(),
+    defaultOrganizationId: z.string().optional(),
+    defaultOrganizationRole: z.string().optional(),
+    emailVerificationDisabled: z.boolean().optional(),
+    emailContent: z.string().optional(),
+    turnstileToken: z.string().optional()
 });
 
 export const GetUserByIdSchema = z.object({
@@ -31,4 +32,19 @@ export const GetUserByIdSchema = z.object({
 export const UpdateUserVerifyTokenSchema = z.object({
     userId: z.string(),
     verifyToken: z.string()
-}); 
+}); 
+
+export const GetUserByEmailSchema = z.object({
+    email: z.string()
+});
+
+export const CredentialLoginSchema = z.object({
+    email: z.string(),
+    password: z.string(),
+    backupCode: z.string().optional(),
+    totpCode: z.string().optional()
+});
+
+export const TokenLoginSchema = z.object({
+    token: z.string()
+});

package/src/modules/accounv1/service.ts

@@ -1,7 +1,7 @@
 
 import z from "zod";
 import { ServiceClient } from "../../service-client";
-import { _CreateUserSchema, GetUserByIdSchema, RegisterUserSchema, UpdateUserVerifyTokenSchema } from "./schema";
+import { _CreateUserSchema, CredentialLoginSchema, GetUserByEmailSchema, GetUserByIdSchema, RegisterUserSchema, TokenLoginSchema, UpdateUserVerifyTokenSchema } from "./schema";
 import { TUser } from "./types";
 
 
@@ -18,6 +18,10 @@ export class AccountService extends ServiceClient {
         return await this.actionCall('user', 'GetUserById', payload);
     }
 
+    public async GetUserByEmail(payload: z.infer<typeof GetUserByEmailSchema>): Promise<TUser> {
+        return await this.actionCall('user', 'GetUserByEmail', payload);
+    }
+
     public async UpdateUserVerifyToken(payload: z.infer<typeof UpdateUserVerifyTokenSchema>): Promise<TUser> {
         return await this.actionCall('user', 'UpdateUserVerifyToken', payload);
     }
@@ -26,6 +30,14 @@ export class AccountService extends ServiceClient {
         return await this.actionCall('user', 'RegisterUser', payload);
     }
 
+    public async CredentialLogin(payload: z.infer<typeof CredentialLoginSchema>): Promise<TUser> {
+        return await this.actionCall('user', 'CredentialLogin', payload);
+    }
+
+    public async TokenLogin(payload: z.infer<typeof TokenLoginSchema>): Promise<TUser> {
+        return await this.actionCall('user', 'TokenLogin', payload);
+    }
+
 
 
 }

package/src/modules/accounv1/types.ts

@@ -12,4 +12,5 @@ export type TUser = {
     googleId: string;
     avatarURL: string;
     locale: string;
+    emailVerified: boolean;
 }