@appconda/nextjs 1.0.115 → 1.0.117

package/dist/actions/actionClient.d.ts

@@ -0,0 +1,10 @@
+export declare const actionClient: import("next-safe-action").SafeActionClient<string, undefined, undefined, undefined, {}, undefined, undefined, undefined, readonly [], {
+    formErrors: string[];
+    fieldErrors: {};
+} | undefined, readonly []>;
+export declare const authenticatedActionClient: import("next-safe-action").SafeActionClient<string, undefined, undefined, undefined, {
+    user: import("..").Models.User<import("..").Models.Preferences>;
+}, undefined, undefined, undefined, readonly [], {
+    formErrors: string[];
+    fieldErrors: {};
+} | undefined, readonly []>;

package/dist/actions/actionClient.js

@@ -0,0 +1,41 @@
+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";
+import { getSDKForCurrentUser } from "../getSDKForCurrentUser";
+export const actionClient = createSafeActionClient({
+    handleServerError(e) {
+        /* if (
+          e instanceof ResourceNotFoundError ||
+          e instanceof AuthorizationError ||
+          e instanceof InvalidInputError ||
+          e instanceof UnknownError ||
+          e instanceof AuthenticationError ||
+          e instanceof OperationNotAllowedError ||
+          e instanceof AppcondaException
+        ) {
+          return e.message;
+        } */
+        // eslint-disable-next-line no-console -- This error needs to be logged for debugging server-side errors
+        console.error("SERVER ERROR: ", e);
+        return DEFAULT_SERVER_ERROR_MESSAGE;
+    },
+});
+export const authenticatedActionClient = actionClient.use(async ({ next }) => {
+    const options = authOptions();
+    const session = options ? await getServerSession(options) : null;
+    //@ts-ignore
+    if (!session?.user) {
+        throw new AuthenticationError("Not authenticated");
+    }
+    //@ts-ignore
+    const userId = session.user.id;
+    // Get the SDK and use users.get method to fetch the user
+    const { users } = await getSDKForCurrentUser();
+    const user = await users.get(userId);
+    if (!user) {
+        throw new AuthorizationError("User not found");
+    }
+    return next({ ctx: { user } });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uQ2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FjdGlvbnMvYWN0aW9uQ2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUM3QyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN4RixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzVDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN4RSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUcvRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsc0JBQXNCLENBQUM7SUFDakQsaUJBQWlCLENBQUMsQ0FBUTtRQUN4Qjs7Ozs7Ozs7OztZQVVJO1FBRUosd0dBQXdHO1FBQ3hHLE9BQU8sQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDbkMsT0FBTyw0QkFBNEIsQ0FBQztJQUN0QyxDQUFDO0NBQ0YsQ0FBQyxDQUFDO0FBR0gsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsWUFBWSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFO0lBQzNFLE1BQU0sT0FBTyxHQUFHLFdBQVcsRUFBRSxDQUFDO0lBQzlCLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQ2pFLFlBQVk7SUFDWixJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDO1FBQ25CLE1BQU0sSUFBSSxtQkFBbUIsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFRCxZQUFZO0lBQ1osTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7SUFFL0IseURBQXlEO0lBQ3pELE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxNQUFNLG9CQUFvQixFQUFFLENBQUM7SUFDL0MsTUFBTSxJQUFJLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3JDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNWLE1BQU0sSUFBSSxrQkFBa0IsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQyxFQUFFLEdBQUcsRUFBRSxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQztBQUNqQyxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIlxuaW1wb3J0IHsgZ2V0U2VydmVyU2Vzc2lvbiB9IGZyb20gXCJuZXh0LWF1dGhcIjtcbmltcG9ydCB7IERFRkFVTFRfU0VSVkVSX0VSUk9SX01FU1NBR0UsIGNyZWF0ZVNhZmVBY3Rpb25DbGllbnQgfSBmcm9tIFwibmV4dC1zYWZlLWFjdGlvblwiO1xuaW1wb3J0IHsgYXV0aE9wdGlvbnMgfSBmcm9tIFwiLi9hdXRoT3B0aW9uc1wiO1xuaW1wb3J0IHsgQXV0aGVudGljYXRpb25FcnJvciwgQXV0aG9yaXphdGlvbkVycm9yIH0gZnJvbSBcIi4uL2xpYi9lcnJvcnNcIjtcbmltcG9ydCB7IGdldFNES0ZvckN1cnJlbnRVc2VyIH0gZnJvbSBcIi4uL2dldFNES0ZvckN1cnJlbnRVc2VyXCI7XG5cblxuZXhwb3J0IGNvbnN0IGFjdGlvbkNsaWVudCA9IGNyZWF0ZVNhZmVBY3Rpb25DbGllbnQoe1xuICBoYW5kbGVTZXJ2ZXJFcnJvcihlOiBFcnJvcikge1xuICAgIC8qIGlmIChcbiAgICAgIGUgaW5zdGFuY2VvZiBSZXNvdXJjZU5vdEZvdW5kRXJyb3IgfHxcbiAgICAgIGUgaW5zdGFuY2VvZiBBdXRob3JpemF0aW9uRXJyb3IgfHxcbiAgICAgIGUgaW5zdGFuY2VvZiBJbnZhbGlkSW5wdXRFcnJvciB8fFxuICAgICAgZSBpbnN0YW5jZW9mIFVua25vd25FcnJvciB8fFxuICAgICAgZSBpbnN0YW5jZW9mIEF1dGhlbnRpY2F0aW9uRXJyb3IgfHxcbiAgICAgIGUgaW5zdGFuY2VvZiBPcGVyYXRpb25Ob3RBbGxvd2VkRXJyb3IgfHxcbiAgICAgIGUgaW5zdGFuY2VvZiBBcHBjb25kYUV4Y2VwdGlvblxuICAgICkge1xuICAgICAgcmV0dXJuIGUubWVzc2FnZTtcbiAgICB9ICovXG5cbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tY29uc29sZSAtLSBUaGlzIGVycm9yIG5lZWRzIHRvIGJlIGxvZ2dlZCBmb3IgZGVidWdnaW5nIHNlcnZlci1zaWRlIGVycm9yc1xuICAgIGNvbnNvbGUuZXJyb3IoXCJTRVJWRVIgRVJST1I6IFwiLCBlKTtcbiAgICByZXR1cm4gREVGQVVMVF9TRVJWRVJfRVJST1JfTUVTU0FHRTtcbiAgfSxcbn0pO1xuXG5cbmV4cG9ydCBjb25zdCBhdXRoZW50aWNhdGVkQWN0aW9uQ2xpZW50ID0gYWN0aW9uQ2xpZW50LnVzZShhc3luYyAoeyBuZXh0IH0pID0+IHtcbiAgY29uc3Qgb3B0aW9ucyA9IGF1dGhPcHRpb25zKCk7XG4gIGNvbnN0IHNlc3Npb24gPSBvcHRpb25zID8gYXdhaXQgZ2V0U2VydmVyU2Vzc2lvbihvcHRpb25zKSA6IG51bGw7XG4gIC8vQHRzLWlnbm9yZVxuICBpZiAoIXNlc3Npb24/LnVzZXIpIHtcbiAgICB0aHJvdyBuZXcgQXV0aGVudGljYXRpb25FcnJvcihcIk5vdCBhdXRoZW50aWNhdGVkXCIpO1xuICB9XG5cbiAgLy9AdHMtaWdub3JlXG4gIGNvbnN0IHVzZXJJZCA9IHNlc3Npb24udXNlci5pZDtcblxuICAvLyBHZXQgdGhlIFNESyBhbmQgdXNlIHVzZXJzLmdldCBtZXRob2QgdG8gZmV0Y2ggdGhlIHVzZXJcbiAgY29uc3QgeyB1c2VycyB9ID0gYXdhaXQgZ2V0U0RLRm9yQ3VycmVudFVzZXIoKTtcbiAgY29uc3QgdXNlciA9IGF3YWl0IHVzZXJzLmdldCh1c2VySWQpO1xuICBpZiAoIXVzZXIpIHtcbiAgICB0aHJvdyBuZXcgQXV0aG9yaXphdGlvbkVycm9yKFwiVXNlciBub3QgZm91bmRcIik7XG4gIH1cblxuICByZXR1cm4gbmV4dCh7IGN0eDogeyB1c2VyIH0gfSk7XG59KTtcbiJdfQ==

package/dist/actions/auth.d.ts

@@ -0,0 +1 @@
+export declare const auth: () => Promise<unknown>;

package/dist/actions/auth.js

@@ -0,0 +1,7 @@
+import { getServerSession } from "next-auth";
+import { authOptions } from "./authOptions";
+export const auth = async () => {
+    const options = authOptions();
+    return options ? await getServerSession(options) : null;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpb25zL2F1dGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQzVDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUMsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLEtBQUssSUFBRyxFQUFFO0lBQzFCLE1BQU0sT0FBTyxHQUFHLFdBQVcsRUFBRSxDQUFDO0lBQzlCLE9BQU8sT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFDNUQsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0U2VydmVyU2Vzc2lvbiB9IGZyb20gXCJuZXh0LWF1dGhcIlxuaW1wb3J0IHsgYXV0aE9wdGlvbnMgfSBmcm9tIFwiLi9hdXRoT3B0aW9uc1wiO1xuXG5leHBvcnQgY29uc3QgYXV0aCA9IGFzeW5jICgpPT4ge1xuICAgIGNvbnN0IG9wdGlvbnMgPSBhdXRoT3B0aW9ucygpO1xuICAgIHJldHVybiBvcHRpb25zID8gYXdhaXQgZ2V0U2VydmVyU2Vzc2lvbihvcHRpb25zKSA6IG51bGw7XG59XG4iXX0=

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/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./actionClient";
+export * from "./auth";
+export * from "./nextAuthHandler";

package/dist/actions/index.js

@@ -0,0 +1,4 @@
+export * from "./actionClient";
+export * from "./auth";
+export * from "./nextAuthHandler";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWN0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hY3Rpb25DbGllbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2F1dGhcIjtcbmV4cG9ydCAqIGZyb20gXCIuL25leHRBdXRoSGFuZGxlclwiO1xuIl19

package/dist/actions/nextAuthHandler.d.ts

@@ -0,0 +1 @@
+export declare const getHandler: () => any;

package/dist/actions/nextAuthHandler.js

@@ -0,0 +1,6 @@
+import NextAuth from "next-auth";
+import { authOptions } from "./authOptions";
+export const getHandler = () => {
+    return NextAuth(authOptions());
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dEF1dGhIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FjdGlvbnMvbmV4dEF1dGhIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUNqQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTVDLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxHQUFHLEVBQUU7SUFDM0IsT0FBTyxRQUFRLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQTtBQUNsQyxDQUFDLENBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJcblxuaW1wb3J0IE5leHRBdXRoIGZyb20gXCJuZXh0LWF1dGhcIjtcbmltcG9ydCB7IGF1dGhPcHRpb25zIH0gZnJvbSBcIi4vYXV0aE9wdGlvbnNcIjtcblxuZXhwb3J0IGNvbnN0IGdldEhhbmRsZXIgPSAoKSA9PiB7XG4gICAgcmV0dXJuIE5leHRBdXRoKGF1dGhPcHRpb25zKCkpXG59IDtcblxuIl19

package/dist/client.d.ts

@@ -0,0 +1,141 @@
+import { Models } from './models';
+type Payload = {
+    [key: string]: any;
+};
+type UploadProgress = {
+    $id: string;
+    progress: number;
+    sizeUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+};
+type Headers = {
+    [key: string]: string;
+};
+declare class AppcondaException extends Error {
+    code: number;
+    response: string;
+    type: string;
+    constructor(message: string, code?: number, type?: string, response?: string);
+}
+declare class Client {
+    static CHUNK_SIZE: number;
+    config: {
+        endpoint: string;
+        selfSigned: boolean;
+        project: string;
+        mode: string;
+        key: string;
+        jwt: string;
+        locale: string;
+        session: string;
+        forwardeduseragent: string;
+    };
+    headers: Headers;
+    /**
+     * Set Endpoint
+     *
+     * Your project endpoint
+     *
+     * @param {string} endpoint
+     *
+     * @returns {this}
+     */
+    setEndpoint(endpoint: string): this;
+    /**
+     * Set self-signed
+     *
+     * @param {boolean} selfSigned
+     *
+     * @returns {this}
+     */
+    setSelfSigned(selfSigned: boolean): this;
+    /**
+     * Add header
+     *
+     * @param {string} header
+     * @param {string} value
+     *
+     * @returns {this}
+     */
+    addHeader(header: string, value: string): this;
+    /**
+     * Set Project
+     *
+     * Your project ID
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setProject(value: string): this;
+    /**
+   * Set Mode
+   *
+   * @param value string
+   *
+   * @return {this}
+   */
+    setMode(value: string): this;
+    /**
+     * Set Key
+     *
+     * Your secret API key
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setKey(value: string): this;
+    /**
+     * Set JWT
+     *
+     * Your secret JSON Web Token
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setJWT(value: string): this;
+    /**
+     * Set Locale
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setLocale(value: string): this;
+    /**
+     * Set Session
+     *
+     * The user session to authenticate with
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setSession(value: string): this;
+    /**
+     * Set ForwardedUserAgent
+     *
+     * The user agent string of the client that made the request
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setForwardedUserAgent(value: string): this;
+    setFallbackCookies(value: string): this;
+    prepareRequest(method: string, url: URL, headers?: Headers, params?: Payload): {
+        uri: string;
+        options: RequestInit;
+    };
+    chunkedUpload(method: string, url: URL, headers: Headers | undefined, originalPayload: Payload | undefined, onProgress: (progress: UploadProgress) => void): Promise<any>;
+    redirect(method: string, url: URL, headers?: Headers, params?: Payload): Promise<string>;
+    call(method: string, url: URL, headers?: Headers, params?: Payload, responseType?: string): Promise<any>;
+    static flatten(data: Payload, prefix?: string): Payload;
+}
+export { Client, AppcondaException };
+export { Query } from './query';
+export type { Models, Payload, UploadProgress };
+export type { QueryTypes, QueryTypesList } from './query';