@appconda/sdk 1.0.194 → 1.0.409

package/.github/workflows/autoclose.yml

@@ -0,0 +1,11 @@
+name: Auto-close External Pull Requests
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+jobs:
+  auto_close:
+    uses: appconda/.github/.github/workflows/autoclose.yml@main
+    secrets:
+      GH_AUTO_CLOSE_PR_TOKEN: ${{ secrets.GH_AUTO_CLOSE_PR_TOKEN }}

package/.github/workflows/publish.yml

@@ -0,0 +1,42 @@
+name: Publish to NPM
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Setup Node.js environment
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        registry-url: 'https://registry.npmjs.org'
+
+    # Determine release tag based on the tag name
+    - name: Determine release tag
+      id: release_tag
+      run: |
+        if [[ "${{ github.ref }}" == *"-rc"* ]] || [[ "${{ github.ref }}" == *"-RC"* ]]; then
+          echo "tag=next" >> "$GITHUB_OUTPUT"
+        else
+          echo "tag=latest" >> "$GITHUB_OUTPUT"
+        fi
+
+    # Install dependencies (if any) and build your project (if necessary)
+    - name: Install dependencies and build
+      run: |
+        npm install
+        npm run build
+
+    # Publish to NPM with the appropriate tag
+    - name: Publish
+      run: npm publish --tag ${{ steps.release_tag.outputs.tag }}
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.travis.yml

@@ -0,0 +1,32 @@
+language: node_js
+node_js:
+  - "14.16"
+
+jobs:
+  include:
+    - stage: NPM RC Release
+      if: tag =~ /-(rc|RC)/
+      node_js: "14.16"
+      script:
+        - npm install
+        - npm run build
+        - echo "Deploying RC to NPM..."
+      deploy:
+        provider: npm
+        email: $NPM_EMAIL
+        api_key: $NPM_API_KEY
+        tag: next
+    - stage: NPM Release
+      if: not tag =~ /-(rc|RC)/
+      node_js: "14.16"
+      script:
+        - npm install
+        - npm run build
+        - echo "Deploying to NPM..."
+      deploy:
+        provider: npm
+        email: $NPM_EMAIL
+        api_key: $NPM_API_KEY
+        skip_cleanup: true
+        on:
+          tags: true

package/CHANGELOG.md

@@ -0,0 +1 @@
+# Change Log

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2024 Appconda (https://appconda.io) and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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/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<any>;
+export declare const authOptions: () => any;

package/dist/actions/authOptions.js

@@ -0,0 +1,133 @@
+import CredentialsProvider from "next-auth/providers/credentials";
+import { cookies } from "next/headers";
+import { getAppcondaClient, getAppcondaClientSync } from "../getAppcondaClient";
+import { AccountService } from "../modules";
+/* 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',
+  };
+}; */
+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);
+    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) {
+                            const adminClient = getAppcondaClientSync();
+                            const accountService = new AccountService(adminClient);
+                            const session = await accountService.CredentialLogin(credentials);
+                            return session;
+                        },
+                    }),
+                    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) {
+                            const adminClient = getAppcondaClientSync();
+                            const accountService = new AccountService(adminClient);
+                            const token = credentials?.token;
+                            const user = await accountService.TokenLogin({ token: token });
+                            return user;
+                        },
+                    }),
+                    // Conditionally add enterprise SSO providers
+                    // ...(ENTERPRISE_LICENSE_KEY ? getSSOProviders() : []),
+                ],
+                callbacks: {
+                    async jwt({ token }) {
+                        const adminClient = getAppcondaClientSync();
+                        const accountService = new AccountService(adminClient);
+                        const existingUser = await accountService.GetUserByEmail({ email: token?.email });
+                        if (!existingUser) {
+                            return token;
+                        }
+                        return {
+                            ...token,
+                            profile: { id: existingUser.id },
+                        };
+                    },
+                    async session({ session, token }) {
+                        // @ts-expect-error
+                        session.user.id = token?.id;
+                        // @ts-expect-error
+                        session.user = token.profile;
+                        return session;
+                    },
+                    async signIn({ user, account }) {
+                        if (account?.provider === "credentials" || account?.provider === "token") {
+                            // check if user's email is verified or not
+                            if (!user.emailVerified && !EMAIL_VERIFICATION_DISABLED) {
+                                throw new Error("Email Verification is Pending");
+                            }
+                            return true;
+                        }
+                        /* if (ENTERPRISE_LICENSE_KEY) {
+                          return handleSSOCallback({ user, account });
+                        } */
+                        return true;
+                    },
+                },
+                pages: {
+                    signIn: "/auth/login",
+                    signOut: "/auth/logout",
+                    error: "/auth/login", // Error code passed in query string as ?error=
+                },
+            };
+        }
+        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 { 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\n\n  return () => {\n   \n\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 adminClient =  getAppcondaClientSync();\n              const accountService = new AccountService(adminClient);\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              const adminClient =  getAppcondaClientSync();\n              const accountService = new AccountService(adminClient);\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 adminClient =  getAppcondaClientSync();\n            const accountService = new AccountService(adminClient);\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/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;