@cedarjs/cli-helpers 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# cli-helpers
+
+This package is used by auth provider setup scripts.

package/dist/auth/authFiles.d.ts

@@ -0,0 +1,44 @@
+interface FilesArgs {
+    basedir: string;
+    webAuthn: boolean;
+}
+/**
+ * Get the api side file paths and file contents to write
+ *
+ * Example return value:
+ * ```json
+ * {
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/auth.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/helperFunctions.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/functions/auth.ts": "<file content>"
+ * }
+ * ```
+ */
+export declare const apiSideFiles: ({ basedir, webAuthn }: FilesArgs) => Promise<Record<string, string>>;
+/**
+ * Loops through the keys in `filesRecord` and generates unique file paths if
+ * they conflict with existing files
+ *
+ * Given this input:
+ * ```json
+ * {
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/auth.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/helperFunctions.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/supertokens.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/functions/auth.ts": "<file content>"
+ * }
+ * ```
+ *
+ * You could get this output, depending on what existing files there are
+ * ```json
+ * {
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/supertokensAuth3.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/supertokensHelperFunctions.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/lib/supertokens2.ts": "<file content>",
+ *   "/Users/tobbe/dev/rw-app/api/src/functions/auth.ts": "<file content>"
+ * }
+ * ```
+ */
+export declare function generateUniqueFileNames(filesRecord: Record<string, string>, provider: string): Record<string, string>;
+export {};
+//# sourceMappingURL=authFiles.d.ts.map

package/dist/auth/authFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authFiles.d.ts","sourceRoot":"","sources":["../../src/auth/authFiles.ts"],"names":[],"mappings":"AASA,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,0BAAiC,SAAS,oCAmElE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,QAAQ,EAAE,MAAM,0BAwCjB"}

package/dist/auth/authFiles.js

@@ -0,0 +1,74 @@
+import fs from "fs";
+import path from "path";
+import pascalcase from "pascalcase";
+import { transformTSToJS } from "../lib/index.js";
+import { getPaths } from "../lib/paths.js";
+import { isTypeScriptProject } from "../lib/project.js";
+const apiSideFiles = async ({ basedir, webAuthn }) => {
+  const apiSrcPath = getPaths().api.src;
+  const apiBaseTemplatePath = path.join(basedir, "templates", "api");
+  const templateDirectories = fs.readdirSync(apiBaseTemplatePath);
+  let filesRecord = {};
+  for (const dir of templateDirectories) {
+    const templateFiles = fs.readdirSync(path.join(apiBaseTemplatePath, dir));
+    const filePaths = templateFiles.filter((fileName) => {
+      const fileNameParts = fileName.split(".");
+      return fileNameParts.length <= 3 || fileNameParts.at(-3) !== "webAuthn";
+    }).map((fileName) => {
+      let outputFileName = fileName.replace(/\.template$/, "");
+      if (!isTypeScriptProject()) {
+        outputFileName = outputFileName.replace(/\.ts(x?)$/, ".js$1");
+      }
+      if (!webAuthn) {
+        return { templateFileName: fileName, outputFileName };
+      }
+      const webAuthnFileName = fileName.split(".").reverse().map((part, i) => i === 1 ? "webAuthn." + part : part).reverse().join(".");
+      if (templateFiles.includes(webAuthnFileName)) {
+        return { templateFileName: webAuthnFileName, outputFileName };
+      } else {
+        return { templateFileName: fileName, outputFileName };
+      }
+    }).map((f) => {
+      const templateFilePath = path.join(
+        apiBaseTemplatePath,
+        dir,
+        f.templateFileName
+      );
+      const outputFilePath = path.join(apiSrcPath, dir, f.outputFileName);
+      return { templateFilePath, outputFilePath };
+    });
+    for (const paths of filePaths) {
+      const content = fs.readFileSync(paths.templateFilePath, "utf8");
+      filesRecord = {
+        ...filesRecord,
+        [paths.outputFilePath]: isTypeScriptProject() ? content : await transformTSToJS(paths.outputFilePath, content)
+      };
+    }
+  }
+  return filesRecord;
+};
+function generateUniqueFileNames(filesRecord, provider) {
+  const newFilesRecord = {};
+  Object.keys(filesRecord).forEach((fullPath) => {
+    let newFullPath = fullPath;
+    let i = 1;
+    while (fs.existsSync(newFullPath)) {
+      const nameParts = path.basename(fullPath).split(".");
+      if (nameParts[0] === provider) {
+        const newFileName = provider + (i + 1) + "." + nameParts.slice(1).join(".");
+        newFullPath = path.join(path.dirname(fullPath), newFileName);
+      } else {
+        const count = i > 1 ? i : "";
+        const newFileName = provider + pascalcase(nameParts[0]) + count + "." + nameParts.slice(1).join(".");
+        newFullPath = path.join(path.dirname(fullPath), newFileName);
+      }
+      i++;
+    }
+    newFilesRecord[newFullPath] = filesRecord[fullPath];
+  });
+  return newFilesRecord;
+}
+export {
+  apiSideFiles,
+  generateUniqueFileNames
+};

package/dist/auth/authTasks.d.ts

@@ -0,0 +1,49 @@
+import type { ListrRenderer, ListrTask, ListrTaskWrapper } from 'listr2';
+export declare const getWebAppPath: () => string;
+export declare const addApiConfig: ({ replaceExistingImport, authDecoderImport, }: {
+    replaceExistingImport: boolean;
+    authDecoderImport?: string;
+}) => void;
+export declare const hasAuthProvider: (content: string) => boolean;
+/**
+ * Removes <AuthProvider ...> and </AuthProvider> if they exist, and un-indents
+ * the content.
+ *
+ * Exported for testing
+ */
+export declare const removeAuthProvider: (content: string) => string;
+/**
+ * Actually inserts the required config lines into App.{jsx,tsx}
+ * Exported for testing
+ */
+export declare const addConfigToWebApp: <Renderer extends typeof ListrRenderer>() => ListrTask<AuthGeneratorCtx, Renderer>;
+export declare const createWebAuth: (basedir: string, webAuthn: boolean) => {
+    title: string;
+    task: (ctx: AuthGeneratorCtx) => Promise<void>;
+};
+export declare const addConfigToRoutes: () => {
+    title: string;
+    task: () => void;
+};
+/**
+ * Will find the templates inside `${basedir}/templates/api`,
+ * and write these files to disk with unique names if they are clashing.
+ *
+ * @returns Listr task
+ */
+export declare const generateAuthApiFiles: <Renderer extends typeof ListrRenderer>(basedir: string, webAuthn: boolean) => ListrTask<AuthGeneratorCtx, Renderer>;
+export declare const addAuthConfigToGqlApi: <Renderer extends typeof ListrRenderer, FallbackRenderer extends typeof ListrRenderer>(authDecoderImport?: string) => {
+    title: string;
+    task: (ctx: AuthGeneratorCtx, _task: ListrTaskWrapper<AuthGeneratorCtx, Renderer, FallbackRenderer>) => void;
+};
+export type AuthSetupMode = 'FORCE' | 'REPLACE' | 'COMBINE' | 'UNKNOWN';
+export interface AuthGeneratorCtx {
+    setupMode: AuthSetupMode;
+    provider: string;
+    force: boolean;
+}
+export declare const setAuthSetupMode: <Renderer extends typeof ListrRenderer, FallbackRenderer extends typeof ListrRenderer>(force: boolean) => {
+    title: string;
+    task: (ctx: AuthGeneratorCtx, task: ListrTaskWrapper<AuthGeneratorCtx, Renderer, FallbackRenderer>) => Promise<void>;
+};
+//# sourceMappingURL=authTasks.d.ts.map

package/dist/auth/authTasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authTasks.d.ts","sourceRoot":"","sources":["../../src/auth/authTasks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAmBxE,eAAO,MAAM,aAAa,cAA2B,CAAA;AAwDrD,eAAO,MAAM,YAAY,kDAGtB;IACD,qBAAqB,EAAE,OAAO,CAAA;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,SAgDA,CAAA;AAmCD,eAAO,MAAM,eAAe,YAAa,MAAM,YAE9C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,YAAa,MAAM,WA6CjD,CAAA;AAoED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,OAAO,aAAa,OAClC,SAAS,CAAC,gBAAgB,EAAE,QAAQ,CA0CxC,CAAA;AAED,eAAO,MAAM,aAAa,YAAa,MAAM,YAAY,OAAO;;gBAgC1C,gBAAgB;CA0CrC,CAAA;AAED,eAAO,MAAM,iBAAiB;;;CAmB7B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,SAAS,OAAO,aAAa,WAC/D,MAAM,YACL,OAAO,KAChB,SAAS,CAAC,gBAAgB,EAAE,QAAQ,CAgDtC,CAAA;AASD,eAAO,MAAM,qBAAqB,GAChC,QAAQ,SAAS,OAAO,aAAa,EACrC,gBAAgB,SAAS,OAAO,aAAa,sBAEzB,MAAM;;gBAInB,gBAAgB,SACd,gBAAgB,CAAC,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,CAAC;CAcvE,CAAA;AAEF,MAAM,MAAM,aAAa,GACrB,OAAO,GACP,SAAS,GACT,SAAS,GACT,SAAS,CAAA;AAEb,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,aAAa,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,SAAS,OAAO,aAAa,EACrC,gBAAgB,SAAS,OAAO,aAAa,SAEtC,OAAO;;gBAKL,gBAAgB,QACf,gBAAgB,CAAC,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,CAAC;CA2CzE,CAAA"}

package/dist/auth/authTasks.js

@@ -0,0 +1,345 @@
+import fs from "fs";
+import path from "path";
+import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
+import { getConfig, resolveFile } from "@cedarjs/project-config";
+import { colors } from "../lib/colors.js";
+import { transformTSToJS, writeFilesTask } from "../lib/index.js";
+import { getPaths } from "../lib/paths.js";
+import {
+  getGraphqlPath,
+  graphFunctionDoesExist,
+  isTypeScriptProject
+} from "../lib/project.js";
+import { apiSideFiles, generateUniqueFileNames } from "./authFiles.js";
+const AUTH_PROVIDER_HOOK_IMPORT = `import { AuthProvider, useAuth } from './auth'`;
+const AUTH_HOOK_IMPORT = `import { useAuth } from './auth'`;
+const getWebAppPath = () => getPaths().web.app;
+function addAuthDecoderToCreateGraphQLHandler(content) {
+  if (!new RegExp("(?=(^.*?createGraphQLHandler))\\1.*\\bauthDecoder", "s").test(
+    content
+  )) {
+    return content.replace(
+      /^(?<indentation>\s*)(loggerConfig:)(.*)$/m,
+      `$<indentation>authDecoder,
+$<indentation>$2$3`
+    );
+  }
+  return content;
+}
+function replaceAuthDecoderImport(content, decoderImport) {
+  return content.replace(/^import { authDecoder .*} from .+/, decoderImport);
+}
+function replaceAuthDecoderArg(content) {
+  return content.replace(/^(\s+)authDecoder\b.+/m, "$1authDecoder,");
+}
+const addApiConfig = ({
+  replaceExistingImport,
+  authDecoderImport
+}) => {
+  const graphqlPath = getGraphqlPath();
+  if (!graphqlPath) {
+    throw new Error("Could not find your graphql file path");
+  }
+  const content = fs.readFileSync(graphqlPath).toString();
+  let newContent = content;
+  if (authDecoderImport) {
+    if (replaceExistingImport) {
+      newContent = replaceAuthDecoderImport(newContent, authDecoderImport);
+      newContent = replaceAuthDecoderArg(newContent);
+    }
+    const didReplace = newContent.includes(authDecoderImport);
+    if (!replaceExistingImport || !didReplace) {
+      newContent = authDecoderImport + "\n" + newContent;
+      newContent = addAuthDecoderToCreateGraphQLHandler(newContent);
+    }
+  }
+  const hasCurrentUserImport = /(^import {.*?getCurrentUser(?!getCurrentUser).*?} from ['"]src\/lib\/auth['"])/s.test(
+    newContent
+  );
+  if (!hasCurrentUserImport) {
+    newContent = newContent.replace(
+      /^(import { db } from ['"]src\/lib\/db['"])$/m,
+      `import { getCurrentUser } from 'src/lib/auth'
+$1`
+    );
+    newContent = newContent.replace(
+      /^(\s*)(loggerConfig:)(.*)$/m,
+      `$1getCurrentUser,
+$1$2$3`
+    );
+  }
+  if (newContent !== content) {
+    fs.writeFileSync(graphqlPath, newContent);
+  }
+};
+const apiSrcDoesExist = () => {
+  return fs.existsSync(path.join(getPaths().api.src));
+};
+const addAuthImportToApp = (content) => {
+  const contentLines = content.split("\n");
+  const importIndex = contentLines.findLastIndex(
+    (line) => /^\s*import (?!.*(?:.css['"]|.scss['"]))/.test(line)
+  );
+  contentLines.splice(importIndex + 1, 0, "", AUTH_PROVIDER_HOOK_IMPORT);
+  return contentLines.join("\n");
+};
+const addAuthImportToRoutes = (content) => {
+  const contentLines = content.split("\n");
+  const importIndex = contentLines.findLastIndex(
+    (line) => /^\s*import (?!.*(?:.css['"]|.scss['"]))/.test(line)
+  );
+  contentLines.splice(importIndex + 1, 0, "", AUTH_HOOK_IMPORT);
+  return contentLines.join("\n");
+};
+const hasAuthProvider = (content) => {
+  return /\s*<AuthProvider([\s>]|$)/.test(content);
+};
+const removeAuthProvider = (content) => {
+  let remove = false;
+  let end = "";
+  let unindent = false;
+  return content.split("\n").reduce((acc, line) => {
+    let keep = !remove;
+    if (hasAuthProvider(line)) {
+      remove = true;
+      keep = false;
+      unindent = true;
+      end = line.replace(/^(\s*)<Auth.*/s, "$1") + ">";
+    }
+    if (hasAuthProvider(line) && line.trimEnd().at(-1) === ">" || line.trimEnd() === end) {
+      remove = false;
+    }
+    if (/\s*<\/AuthProvider>/.test(line)) {
+      keep = false;
+      unindent = false;
+    }
+    if (keep) {
+      if (unindent) {
+        acc.push(line.replace("  ", ""));
+      } else {
+        acc.push(line);
+      }
+    }
+    return acc;
+  }, []).join("\n");
+};
+const addAuthProviderToApp = (content, setupMode) => {
+  if (setupMode === "FORCE" || setupMode === "REPLACE") {
+    content = removeAuthProvider(content);
+  }
+  const match = content.match(
+    /(\s+)(<RedwoodProvider.*?>)(.*)(<\/RedwoodProvider>)/s
+  );
+  if (!match) {
+    throw new Error("Could not find <RedwoodProvider> in App.{jsx,tsx}");
+  }
+  if (/\s+<AuthProvider>/.test(content)) {
+    return content;
+  }
+  const [
+    _,
+    newlineAndIndent,
+    redwoodProviderOpen,
+    redwoodProviderChildren,
+    redwoodProviderClose
+  ] = match;
+  const redwoodProviderChildrenLines = redwoodProviderChildren.split("\n").map((line, index) => {
+    return `${index === 0 ? "" : "  "}` + line;
+  });
+  const renderContent = newlineAndIndent + redwoodProviderOpen + newlineAndIndent + `  <AuthProvider>` + redwoodProviderChildrenLines.join("\n") + `</AuthProvider>` + newlineAndIndent + redwoodProviderClose;
+  return content.replace(
+    /\s+<RedwoodProvider.*?>.*<\/RedwoodProvider>/s,
+    renderContent
+  );
+};
+const hasUseAuthHook = (componentName, content) => {
+  return new RegExp(
+    `<${componentName}.*useAuth={.*?}.*?>.*</${componentName}>`,
+    "s"
+  ).test(content);
+};
+const addUseAuthHook = (componentName, content) => {
+  return content.replace(
+    `<${componentName}`,
+    `<${componentName} useAuth={useAuth}`
+  );
+};
+const addConfigToWebApp = () => {
+  return {
+    title: "Updating web/src/App.{jsx,tsx}",
+    task: (ctx, task) => {
+      const webAppPath = getWebAppPath();
+      if (!fs.existsSync(webAppPath)) {
+        const ext = isTypeScriptProject() ? "tsx" : "jsx";
+        throw new Error(`Could not find root App.${ext}`);
+      }
+      let content = fs.readFileSync(webAppPath, "utf-8");
+      if (!content.includes(AUTH_PROVIDER_HOOK_IMPORT)) {
+        content = addAuthImportToApp(content);
+      }
+      if (ctx.setupMode === "REPLACE" || ctx.setupMode === "FORCE") {
+        content = content.replace(
+          "import { AuthProvider } from '@cedarjs/auth'\n",
+          ""
+        );
+      }
+      content = addAuthProviderToApp(content, ctx.setupMode);
+      if (/\s*<RedwoodApolloProvider/.test(content)) {
+        if (!hasUseAuthHook("RedwoodApolloProvider", content)) {
+          content = addUseAuthHook("RedwoodApolloProvider", content);
+        }
+      } else {
+        task.output = colors.warning(
+          "Could not find <RedwoodApolloProvider>.\nIf you are using a custom GraphQL Client you will have to make sure it gets access to your `useAuth`, if it needs it."
+        );
+      }
+      fs.writeFileSync(webAppPath, content);
+    }
+  };
+};
+const createWebAuth = (basedir, webAuthn) => {
+  const templatesBaseDir = path.join(basedir, "templates", "web");
+  const templates = fs.readdirSync(templatesBaseDir);
+  const rscEnabled = getConfig().experimental?.rsc?.enabled;
+  const templateStart = "auth" + (webAuthn ? ".webAuthn" : "") + (rscEnabled ? ".rsc" : "") + ".ts";
+  const templateFileName = templates.find((template) => {
+    return template.startsWith(templateStart);
+  });
+  if (!templateFileName) {
+    throw new Error(
+      "Could not find the auth.ts(x) template, looking for filename starting with " + templateStart
+    );
+  }
+  const templateExtension = templateFileName.split(".").at(-2);
+  const isTSProject = isTypeScriptProject();
+  let ext = templateExtension;
+  if (!isTypeScriptProject()) {
+    ext = ext?.replace("ts", "js");
+  }
+  return {
+    title: `Creating web/src/auth.${ext}`,
+    task: async (ctx) => {
+      let authFileName = path.join(getPaths().web.src, "auth");
+      if (ctx.setupMode === "COMBINE") {
+        let i = 1;
+        while (resolveFile(authFileName)) {
+          const count = i > 1 ? i : "";
+          authFileName = path.join(
+            getPaths().web.src,
+            ctx.provider + "Auth" + count
+          );
+          i++;
+        }
+      }
+      authFileName = authFileName + "." + ext;
+      let template = fs.readFileSync(
+        path.join(templatesBaseDir, templateFileName),
+        "utf-8"
+      );
+      template = isTSProject ? template : await transformTSToJS(authFileName, template);
+      fs.writeFileSync(authFileName, template);
+    }
+  };
+};
+const addConfigToRoutes = () => {
+  return {
+    title: "Updating Routes file...",
+    task: () => {
+      const webRoutesPath = getPaths().web.routes;
+      let content = fs.readFileSync(webRoutesPath).toString();
+      if (!content.includes(AUTH_HOOK_IMPORT)) {
+        content = addAuthImportToRoutes(content);
+      }
+      if (!hasUseAuthHook("Router", content)) {
+        content = addUseAuthHook("Router", content);
+      }
+      fs.writeFileSync(webRoutesPath, content);
+    }
+  };
+};
+const generateAuthApiFiles = (basedir, webAuthn) => {
+  return {
+    title: "Generating auth api side files...",
+    task: async (ctx, task) => {
+      if (!apiSrcDoesExist()) {
+        return new Error(
+          "Could not find api/src directory. Cannot continue setup!"
+        );
+      }
+      let filesRecord = await apiSideFiles({ basedir, webAuthn });
+      let existingFiles = "FAIL";
+      if (ctx.setupMode === "FORCE") {
+        existingFiles = "OVERWRITE";
+      } else if (ctx.setupMode === "REPLACE") {
+        const filesToOverwrite = findExistingFiles(filesRecord);
+        const prompt = task.prompt(ListrEnquirerPromptAdapter);
+        const overwrite = await prompt.run({
+          type: "confirm",
+          message: `Overwrite existing ${filesToOverwrite.join(", ")}?`,
+          initial: false
+        });
+        existingFiles = overwrite ? "OVERWRITE" : "SKIP";
+      } else if (ctx.setupMode === "COMBINE") {
+        const uniqueFilesRecord = generateUniqueFileNames(
+          filesRecord,
+          ctx.provider
+        );
+        filesRecord = uniqueFilesRecord;
+        existingFiles = "FAIL";
+      }
+      return writeFilesTask(filesRecord, {
+        existingFiles
+      });
+    }
+  };
+};
+function findExistingFiles(filesMap) {
+  return Object.keys(filesMap).filter((filePath) => fs.existsSync(filePath)).map((filePath) => filePath.replace(getPaths().base, ""));
+}
+const addAuthConfigToGqlApi = (authDecoderImport) => ({
+  title: "Adding auth config to GraphQL API...",
+  task: (ctx, _task) => {
+    if (graphFunctionDoesExist()) {
+      addApiConfig({
+        authDecoderImport,
+        replaceExistingImport: ctx.setupMode === "REPLACE" || ctx.setupMode === "FORCE"
+      });
+    } else {
+      throw new Error(
+        "GraphQL function not found. You will need to pass the decoder to the createGraphQLHandler function."
+      );
+    }
+  }
+});
+const setAuthSetupMode = (force) => {
+  return {
+    title: "Checking project for existing auth...",
+    task: async (ctx, task) => {
+      if (force) {
+        ctx.setupMode = "FORCE";
+        return;
+      }
+      const webAppContents = fs.readFileSync(getWebAppPath(), "utf-8");
+      if (hasAuthProvider(webAppContents) && ctx.setupMode === "UNKNOWN") {
+        const setupMode = "REPLACE";
+        ctx.setupMode = setupMode;
+        return;
+      } else {
+        ctx.setupMode = "FORCE";
+        task.skip("Setting up Auth from scratch");
+      }
+    }
+  };
+};
+export {
+  addApiConfig,
+  addAuthConfigToGqlApi,
+  addConfigToRoutes,
+  addConfigToWebApp,
+  createWebAuth,
+  generateAuthApiFiles,
+  getWebAppPath,
+  hasAuthProvider,
+  removeAuthProvider,
+  setAuthSetupMode
+};

package/dist/auth/setupHelpers.d.ts

@@ -0,0 +1,26 @@
+import type { ListrTask } from 'listr2';
+import type { Argv } from 'yargs';
+import type { AuthGeneratorCtx } from './authTasks.js';
+export declare const standardAuthBuilder: (yargs: Argv) => Argv<{
+    force: boolean;
+} & {
+    verbose: boolean;
+}>;
+export interface AuthHandlerArgs {
+    basedir: string;
+    forceArg: boolean;
+    provider: string;
+    authDecoderImport?: string;
+    webAuthn?: boolean;
+    webPackages?: string[];
+    apiPackages?: string[];
+    extraTasks?: (ListrTask<AuthGeneratorCtx> | undefined)[];
+    notes?: string[];
+    verbose?: boolean;
+}
+/**
+ * basedir assumes that you must have a templates folder in that directory.
+ * See folder structure of auth providers in packages/auth-providers/<provider>/setup/src
+ */
+export declare const standardAuthHandler: ({ basedir, forceArg, provider, authDecoderImport, webAuthn, webPackages, apiPackages, extraTasks, notes, verbose, }: AuthHandlerArgs) => Promise<void>;
+//# sourceMappingURL=setupHelpers.d.ts.map

package/dist/auth/setupHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupHelpers.d.ts","sourceRoot":"","sources":["../../src/auth/setupHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAGvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAWjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAUtD,eAAO,MAAM,mBAAmB,UAAW,IAAI;;;;EAoB9C,CAAA;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,UAAU,CAAC,EAAE,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC,EAAE,CAAA;IACxD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AASD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,wHAW7B,eAAe,kBAiFjB,CAAA"}