@slicemachine/init 0.1.1-beta.1 → 0.1.1-dev-plugins.3

package/dist/SliceMachineInitProcess.js

@@ -0,0 +1,664 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import chalk from "chalk";
+import open from "open";
+import logSymbols from "log-symbols";
+import { globby } from './__node_modules/globby/index.js';
+import { createSliceMachineManager } from "@slicemachine/manager";
+import { detectFramework } from "./lib/framework.js";
+import { installDependencies, detectPackageManager } from "./lib/packageManager.js";
+import { formatRepositoryDomain, validateRepositoryDomainAndAvailability, getErrorMessageForRepositoryDomainValidation, getRandomRepositoryDomain, validateRepositoryDomain } from "./lib/repositoryDomain.js";
+import { listrRun, listr } from "./lib/listr.js";
+import { prompt } from "./lib/prompt.js";
+import { assertExists } from "./lib/assertExists.js";
+const DEFAULT_OPTIONS = {
+  push: true,
+  pushSlices: true,
+  pushCustomTypes: true,
+  pushDocuments: true
+};
+const createSliceMachineInitProcess = (options) => {
+  return new SliceMachineInitProcess(options);
+};
+class SliceMachineInitProcess {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "manager");
+    __publicField(this, "context");
+    __publicField(this, "trackError", (error) => {
+      var _a, _b;
+      const safeError = (error instanceof Error ? error.message : `${error}`).slice(0, 512);
+      return this.manager.telemetry.track({
+        event: "command:init:end",
+        framework: ((_a = this.context.framework) == null ? void 0 : _a.prismicName) ?? "unknown",
+        repository: (_b = this.context.repository) == null ? void 0 : _b.domain,
+        success: false,
+        error: safeError
+      });
+    });
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.manager = createSliceMachineManager({ cwd: options == null ? void 0 : options.cwd });
+    this.context = {};
+  }
+  async run() {
+    console.log(`
+${chalk.bgGray(` ${chalk.bold.white("Slice Machine")} `)} ${chalk.dim("→")} Init command started
+`);
+    await this.manager.telemetry.initTelemetry();
+    await this.manager.telemetry.track({
+      event: "command:init:start",
+      repository: this.options.repository
+    });
+    try {
+      await this.detectEnvironment();
+      assertExists(this.context.framework, "Project framework must be available through context to proceed");
+      await this.beginCoreDependenciesInstallation();
+      await this.loginAndFetchUserData();
+      if (this.options.repository) {
+        await this.useRepositoryFlag();
+      } else {
+        await this.selectRepository();
+      }
+      assertExists(this.context.repository, "Repository selection must be available through context to proceed");
+      if (!this.context.repository.exists) {
+        await this.createNewRepository();
+      }
+      await this.finishCoreDependenciesInstallation();
+      await this.upsertSliceMachineConfigurationAndStartPluginRunner();
+      await this.pushDataToPrismic();
+      await this.initializePlugins();
+    } catch (error) {
+      await this.trackError(error);
+      throw error;
+    }
+    await this.manager.telemetry.track({
+      event: "command:init:end",
+      framework: this.context.framework.prismicName,
+      repository: this.context.repository.domain,
+      success: true
+    });
+    console.log(`
+${chalk.bgGreen(` ${chalk.bold.white("Slice Machine")} `)} ${chalk.dim("→")} Init command successful!`);
+  }
+  detectEnvironment() {
+    return listrRun([
+      {
+        title: "Detecting environment...",
+        task: (_, parentTask) => listr([
+          {
+            title: "Detecting framework...",
+            task: async (_2, task) => {
+              this.context.framework = await detectFramework(this.manager.cwd);
+              task.title = `Detected framework ${chalk.cyan(this.context.framework.name)}`;
+            }
+          },
+          {
+            title: "Detecting package manager...",
+            task: async (_2, task) => {
+              this.context.packageManager = await detectPackageManager();
+              task.title = `Detected package manager ${chalk.cyan(this.context.packageManager)}`;
+              assertExists(this.context.framework, "Project framework must be available through context to proceed");
+              parentTask.title = `Detected framework ${chalk.cyan(this.context.framework.name)} and package manager ${chalk.cyan(this.context.packageManager)}`;
+            }
+          }
+        ])
+      }
+    ]);
+  }
+  beginCoreDependenciesInstallation() {
+    return listrRun([
+      {
+        title: "Beginning core dependencies installation...",
+        task: async (_, task) => {
+          assertExists(this.context.packageManager, "Project package manager must be available through context to run `beginCoreDependenciesInstallation`");
+          assertExists(this.context.framework, "Project framework must be available through context to run `beginCoreDependenciesInstallation`");
+          const { execaProcess } = await installDependencies({
+            agent: this.context.packageManager,
+            dependencies: this.context.framework.devDependencies,
+            dev: true
+          });
+          execaProcess.catch(async (error) => {
+            const [_2, ...argv1n] = process.argv;
+            let tryAgainCommand = [process.argv0, ...argv1n].join(" ");
+            if (!this.options.repository && this.context.repository) {
+              tryAgainCommand = `${tryAgainCommand} --repository=${this.context.repository.domain}`;
+            }
+            await this.trackError(error.shortMessage);
+            console.error(`
+
+${error.shortMessage}
+${error.stderr}
+
+${logSymbols.error} Dependency installation failed, try again with:
+
+  ${chalk.gray("$")} ${chalk.cyan(tryAgainCommand)}`);
+            process.exit(1);
+          });
+          this.context.installProcess = execaProcess;
+          task.title = `Began core dependencies installation with ${chalk.cyan(this.context.packageManager)} ... (running in background)`;
+        }
+      }
+    ]);
+  }
+  loginAndFetchUserData() {
+    return listrRun([
+      {
+        title: "Logging in to Prismic...",
+        task: async (_, parentTask) => {
+          parentTask.output = "Validating session...";
+          const isLoggedIn = await this.manager.user.checkIsLoggedIn();
+          if (!isLoggedIn) {
+            parentTask.output = "Press any key to open the browser to login...";
+            await new Promise((resolve) => {
+              const initialRawMode = process.stdin.isRaw;
+              process.stdin.setRawMode(true);
+              process.stdin.once("data", (data) => {
+                process.stdin.setRawMode(initialRawMode);
+                process.stdin.pause();
+                resolve(data.toString("utf-8"));
+              });
+            });
+            parentTask.output = "Browser opened, waiting for you to login...";
+            const { port, url } = await this.manager.user.getLoginSessionInfo();
+            await this.manager.user.nodeLoginSession({
+              port,
+              onListenCallback() {
+                open(url).catch((error) => {
+                  throw error;
+                });
+              }
+            });
+          }
+          parentTask.output = "";
+          parentTask.title = `Logged in`;
+          return listr([
+            {
+              title: "Fetching user profile...",
+              task: async (_2, task) => {
+                var _a;
+                this.context.userProfile = await this.manager.user.getProfile();
+                await this.manager.telemetry.identify({
+                  userID: this.context.userProfile.shortId,
+                  intercomHash: this.context.userProfile.intercomHash
+                });
+                await this.manager.telemetry.track({
+                  event: "command:init:identify",
+                  repository: this.options.repository
+                });
+                parentTask.title = `Logged in as ${chalk.cyan((_a = this.context.userProfile) == null ? void 0 : _a.email)}`;
+                task.title = "Fetched user profile";
+              }
+            },
+            {
+              title: "Fetching user repositories...",
+              task: async (_2, task) => {
+                this.context.userRepositories = await this.manager.prismicRepository.readAll();
+                task.title = "Fetched user repositories";
+              }
+            }
+          ], { concurrent: true });
+        }
+      }
+    ]);
+  }
+  useRepositoryFlag() {
+    return listrRun([
+      {
+        title: `Flag ${chalk.cyan("repository")} used, validating input...`,
+        task: async (_, task) => {
+          assertExists(this.context.userRepositories, "User repositories must be available through context to run `useRepositoryFlag`");
+          assertExists(this.options.repository, "Flag `repository` must be set to run `useRepositoryFlag`");
+          const maybeRepository = this.context.userRepositories.find((repository) => repository.domain === this.options.repository);
+          if (maybeRepository) {
+            if (!this.manager.prismicRepository.hasWriteAccess(maybeRepository)) {
+              throw new Error(`Cannot run init command with repository ${chalk.cyan(maybeRepository.domain)}: you are not a developer or admin of this repository`);
+            }
+          } else {
+            const domain = formatRepositoryDomain(this.options.repository);
+            const validation = await validateRepositoryDomainAndAvailability({
+              domain,
+              existsFn: (domain2) => this.manager.prismicRepository.checkExists({ domain: domain2 })
+            });
+            const errorMessage = getErrorMessageForRepositoryDomainValidation({
+              validation,
+              displayDomain: chalk.cyan(domain)
+            });
+            if (errorMessage) {
+              throw new Error(errorMessage);
+            }
+          }
+          task.title = `Selected repository ${chalk.cyan(this.options.repository)} (flag ${chalk.cyan("repository")} used)`;
+          this.context.repository = {
+            domain: this.options.repository,
+            exists: !!maybeRepository
+          };
+        }
+      }
+    ]);
+  }
+  async selectRepository() {
+    assertExists(this.context.userRepositories, "User repositories must be available through context to run `selectRepository`");
+    if (this.context.userRepositories.length) {
+      await this.trySelectExistingRepository();
+    }
+    if (!this.context.repository) {
+      await this.selectNewRepository();
+    }
+    assertExists(this.context.repository, "Repository selection must be available through context to proceed");
+    console.log(`${logSymbols.success} Selected repository ${chalk.cyan(this.context.repository.domain)}`);
+  }
+  async trySelectExistingRepository() {
+    assertExists(this.context.userRepositories, "User repositories must be available through context to run `trySelectExistingRepository`");
+    const { maybeDomain } = await prompt({
+      type: "select",
+      name: "maybeDomain",
+      message: "Pick a repository to connect to or choose to create a new one",
+      warn: "You are not a developer or admin of this repository",
+      choices: [
+        {
+          title: "CREATE NEW",
+          description: "Create a new Prismic repository\n",
+          value: ""
+        },
+        ...this.context.userRepositories.map((repository) => {
+          const hasWriteAccess = this.manager.prismicRepository.hasWriteAccess(repository);
+          return {
+            title: `${repository.domain}${hasWriteAccess ? "" : " (Unauthorized)"}`,
+            description: `Connect to ${chalk.cyan(repository.domain)}`,
+            value: repository.domain,
+            disabled: !hasWriteAccess
+          };
+        }).sort((a, b) => a.value > b.value ? 1 : -1)
+      ]
+    });
+    if (maybeDomain) {
+      this.context.repository = {
+        domain: maybeDomain,
+        exists: true
+      };
+    }
+  }
+  async selectNewRepository() {
+    let suggestedName = "";
+    const trySuggestName = async (name) => {
+      if (name) {
+        const formattedName = formatRepositoryDomain(name);
+        if (!validateRepositoryDomain({ domain: formattedName }).hasErrors && !await this.manager.prismicRepository.checkExists({
+          domain: formattedName
+        })) {
+          return formattedName;
+        }
+      }
+    };
+    try {
+      const pkgJSONPath = path.join(this.manager.cwd, "package.json");
+      const pkg = JSON.parse(await fs.readFile(pkgJSONPath, "utf-8"));
+      const maybeSuggestion = await trySuggestName(pkg.name);
+      if (maybeSuggestion) {
+        suggestedName = maybeSuggestion;
+      }
+    } catch {
+    }
+    if (!suggestedName) {
+      const maybeSuggestion = await trySuggestName(path.basename(this.manager.cwd));
+      if (maybeSuggestion) {
+        suggestedName = maybeSuggestion;
+      }
+    }
+    if (!suggestedName) {
+      suggestedName = getRandomRepositoryDomain();
+      while (await this.manager.prismicRepository.checkExists({
+        domain: suggestedName
+      })) {
+        suggestedName = getRandomRepositoryDomain();
+      }
+    }
+    const { domain } = await prompt({
+      type: "text",
+      name: "domain",
+      // Overriden by the `onRender` function, just used as a fallback
+      message: "Choose a name for your Prismic repository",
+      initial: suggestedName,
+      onRender() {
+        const rawDomain = this.value || this.initial || "";
+        const domain2 = formatRepositoryDomain(rawDomain);
+        const validation = validateRepositoryDomain({ domain: domain2 });
+        this.msg = chalk.reset(`
+Choose a name for your Prismic repository
+
+  NAMING RULES
+${chalk[validation.LessThan4 ? "red" : "gray"](`    1. Name must be ${chalk[validation.LessThan4 ? "bold" : "cyan"]("4 characters long or more")}`)}
+${chalk[validation.MoreThan30 ? "red" : "gray"](`    2. Name must be ${chalk[validation.MoreThan30 ? "bold" : "cyan"]("30 characters long or less")}`)}
+${chalk.gray(`    3. Name will be ${chalk.cyan("kebab-cased")} automatically`)}
+
+  CONSIDERATIONS
+${chalk.gray(`    1. Once picked, your repository name ${chalk.cyan("cannot be changed")}`)}
+${chalk.gray(`    2. A ${chalk.cyan("display name")} for the repository can be configured later on`)}
+
+  PREVIEW
+${chalk.gray(`    Dashboard  ${chalk.cyan(`https://${domain2}.prismic.io`)}`)}
+${chalk.gray(`    API        ${chalk.cyan(`https://${domain2}.cdn.prismic.io/api/v2`)}`)}
+
+${chalk.cyan("?")} Your Prismic repository name`.replace("\n", ""));
+      },
+      validate: async (rawDomain) => {
+        const domain2 = formatRepositoryDomain(rawDomain);
+        const validation = await validateRepositoryDomainAndAvailability({
+          domain: domain2,
+          existsFn: (domain3) => this.manager.prismicRepository.checkExists({ domain: domain3 })
+        });
+        const errorMessage = getErrorMessageForRepositoryDomainValidation({
+          validation,
+          displayDomain: chalk.cyan(domain2)
+        });
+        return errorMessage || true;
+      },
+      format: (value) => {
+        return formatRepositoryDomain(value);
+      }
+    });
+    process.stdout.moveCursor(0, -16);
+    process.stdout.clearScreenDown();
+    this.context.repository = {
+      domain,
+      exists: false
+    };
+  }
+  createNewRepository() {
+    assertExists(this.context.repository, "Repository selection must be available through context to run `createNewRepository`");
+    return listrRun([
+      {
+        title: `Creating new repository ${chalk.cyan(this.context.repository.domain)} ...`,
+        task: async (_, task) => {
+          assertExists(this.context.repository, "Repository selection must be available through context to run `createNewRepository`");
+          assertExists(this.context.framework, "Project framework must be available through context to run `createNewRepository`");
+          await this.manager.prismicRepository.create({
+            domain: this.context.repository.domain,
+            framework: this.context.framework.prismicName
+          });
+          this.context.repository.exists = true;
+          task.title = `Created new repository ${chalk.cyan(this.context.repository.domain)}`;
+        }
+      }
+    ]);
+  }
+  finishCoreDependenciesInstallation() {
+    return listrRun([
+      {
+        title: `Finishing core dependencies installation with ${chalk.cyan(this.context.packageManager)} ...`,
+        task: async (_, task) => {
+          var _a, _b;
+          assertExists(this.context.installProcess, "Initial dependencies installation process must be available through context to run `finishCoreDependenciesInstallation`");
+          const updateOutput = (data) => {
+            if (data instanceof Buffer) {
+              task.output = data.toString();
+            }
+          };
+          (_a = this.context.installProcess.stdout) == null ? void 0 : _a.on("data", updateOutput);
+          (_b = this.context.installProcess.stderr) == null ? void 0 : _b.on("data", updateOutput);
+          try {
+            await this.context.installProcess;
+          } catch (error) {
+            await new Promise(() => {
+              setTimeout(() => {
+                throw error;
+              }, 5e3);
+            });
+          }
+          task.title = `Core dependencies installed with ${chalk.cyan(this.context.packageManager)}`;
+        }
+      }
+    ]);
+  }
+  upsertSliceMachineConfigurationAndStartPluginRunner() {
+    return listrRun([
+      {
+        title: "Resolving Slice Machine configuration...",
+        task: async (_, parentTask) => {
+          assertExists(this.context.framework, "Project framework must be available through context to run `upsertSliceMachineConfiguration`");
+          assertExists(this.context.repository, "Repository selection must be available through context to run `upsertSliceMachineConfiguration`");
+          let sliceMachineConfigExists = false;
+          try {
+            await this.manager.project.getSliceMachineConfigPath();
+            sliceMachineConfigExists = true;
+          } catch {
+          }
+          if (sliceMachineConfigExists) {
+            parentTask.title = "Updating Slice Machine configuration...";
+            const config = await this.manager.project.getSliceMachineConfig();
+            await this.manager.project.writeSliceMachineConfig({
+              config: {
+                ...config,
+                repositoryName: this.context.repository.domain
+              }
+            });
+            parentTask.title = "Updated Slice Machine configuration";
+          } else {
+            parentTask.title = "Creating Slice Machine configuration...";
+            const sliceMachineConfigPath = await this.manager.project.suggestSliceMachineConfigPath();
+            await this.manager.project.writeSliceMachineConfig({
+              config: {
+                // TODO: Update _latest to a real value or make it optional
+                _latest: "legacy",
+                repositoryName: this.context.repository.domain,
+                adapter: this.context.framework.adapterName,
+                libraries: ["./slices"]
+              },
+              path: sliceMachineConfigPath
+            });
+            parentTask.title = "Created Slice Machine configuration";
+          }
+          return listr([
+            {
+              title: "Starting plugin runner...",
+              task: async (_2, task) => {
+                await this.manager.plugins.initPlugins();
+                task.title = "Started plugin runner";
+                parentTask.title = `${parentTask.title} and started plugin runner`;
+              }
+            }
+          ]);
+        }
+      }
+    ]);
+  }
+  pushDataToPrismic() {
+    return listrRun([
+      {
+        title: "Pushing data to Prismic...",
+        task: (_, parentTask) => listr([
+          {
+            title: "Pushing slices...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushSlices) {
+                return `--no-push-slices used`;
+              }
+            },
+            task: async (_2, task) => {
+              const { libraries, errors } = await this.manager.slices.readAllSliceLibraries();
+              if (errors.length > 0) {
+                throw new Error(`Failed to read slice libraries: ${errors.join(", ")}`);
+              }
+              const slices = [];
+              for (const library of libraries) {
+                if (library.sliceIDs) {
+                  for (const sliceID of library.sliceIDs) {
+                    slices.push({
+                      libraryID: library.libraryID,
+                      sliceID
+                    });
+                  }
+                }
+              }
+              if (slices.length === 0) {
+                task.skip("No slice to push");
+                return;
+              }
+              let pushed = 0;
+              task.title = `Pushing slices... (0/${slices.length})`;
+              await Promise.all(slices.map(async (slice) => {
+                await this.manager.slices.pushSlice(slice);
+                pushed++;
+                task.title = `Pushing slices... (${pushed}/${slices.length})`;
+              }));
+              task.title = "Pushed all slices";
+            }
+          },
+          {
+            title: "Pushing custom types...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushCustomTypes) {
+                return `--no-push-custom-types used`;
+              }
+            },
+            task: async (_2, task) => {
+              const { ids, errors } = await this.manager.customTypes.readCustomTypeLibrary();
+              if (errors.length > 0) {
+                throw new Error(`Failed to read custom type libraries: ${errors.join(", ")}`);
+              }
+              if (!ids || ids.length === 0) {
+                task.skip("No custom type to push");
+                return;
+              }
+              let pushed = 0;
+              task.title = `Pushing custom types... (0/${ids.length})`;
+              await Promise.all(ids.map(async (id) => {
+                await this.manager.customTypes.pushCustomType({ id });
+                pushed++;
+                task.title = `Pushing custom types... (${pushed}/${ids.length})`;
+              }));
+              task.title = "Pushed all custom types";
+            }
+          },
+          {
+            title: "Pushing documents...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushDocuments) {
+                return `--no-push-documents used`;
+              }
+            },
+            task: async (_2, task) => {
+              assertExists(this.context.repository, "Repository selection must be available through context to run `pushDataToPrismic`");
+              const root = await this.manager.project.getRoot();
+              const documentsDirectoryPath = path.resolve(root, "documents");
+              try {
+                await fs.access(documentsDirectoryPath);
+              } catch {
+                parentTask.title = "Pushed data to Prismic";
+                task.skip("No document to push");
+                return;
+              }
+              const signaturePath = path.resolve(documentsDirectoryPath, "index.json");
+              const rawSignature = await fs.readFile(signaturePath, "utf-8");
+              const signature = JSON.parse(rawSignature).signature;
+              const documentsGlob = await globby("*/*.json", {
+                cwd: documentsDirectoryPath
+              });
+              if (documentsGlob.length === 0) {
+                parentTask.title = "Pushed data to Prismic";
+                task.skip("No documents to push");
+                return;
+              }
+              const documents = await Promise.all(documentsGlob.map(async (document) => {
+                const filename = path.basename(document, ".json");
+                const fileContent = await fs.readFile(path.resolve(documentsDirectoryPath, document), "utf-8");
+                return [filename, JSON.parse(fileContent)];
+              }));
+              await this.manager.prismicRepository.pushDocuments({
+                domain: this.context.repository.domain,
+                documents: Object.fromEntries(documents),
+                signature
+              });
+              task.title = "Pushed all documents";
+              parentTask.title = "Pushed data to Prismic";
+            }
+          },
+          {
+            title: "Cleaning up data push artifacts",
+            task: async (_2, task) => {
+              const root = await this.manager.project.getRoot();
+              const documentsDirectoryPath = path.resolve(root, "documents");
+              try {
+                await fs.rm(documentsDirectoryPath, {
+                  force: true,
+                  recursive: true
+                });
+              } catch {
+              }
+              task.title = "Cleaned up data push artifacts";
+              parentTask.title = "Pushed data to Prismic";
+            }
+          }
+        ])
+      }
+    ]);
+  }
+  // TODO: Add Slice Machine script to package.json
+  initializePlugins() {
+    return listrRun([
+      {
+        title: "Initializing plugins...",
+        task: async (_, task) => {
+          const updateOutput = (data) => {
+            if (data instanceof Buffer) {
+              task.output = data.toString();
+            } else if (typeof data === "string") {
+              task.output = data;
+            }
+          };
+          const { errors } = await this.manager.plugins.dangerouslyCallHook("command:init", {
+            log: updateOutput,
+            installDependencies: async (args) => {
+              var _a, _b;
+              assertExists(this.context.packageManager, "Project package manager must be available through context to run `initializePlugins`");
+              try {
+                const { execaProcess } = await installDependencies({
+                  ...args,
+                  agent: this.context.packageManager
+                });
+                (_a = execaProcess.stdout) == null ? void 0 : _a.on("data", updateOutput);
+                (_b = execaProcess.stderr) == null ? void 0 : _b.on("data", updateOutput);
+                await execaProcess;
+              } catch (error) {
+                if (error instanceof Error && "shortMessage" in error && "stderr" in error) {
+                  await this.trackError(error.shortMessage);
+                  console.error(`
+
+${error.shortMessage}
+${error.stderr}
+
+${logSymbols.error} Plugins dependency installation failed`);
+                } else {
+                  await this.trackError(error);
+                  console.error(error);
+                }
+                process.exit(1);
+              }
+            }
+          });
+          if (errors.length > 0) {
+            throw new Error(`Failed to initialize plugins: ${errors.join(", ")}`);
+          }
+          task.title = "Initialized plugins";
+        }
+      }
+    ]);
+  }
+}
+export {
+  SliceMachineInitProcess,
+  createSliceMachineInitProcess
+};
+//# sourceMappingURL=SliceMachineInitProcess.js.map