@slicemachine/init 1.1.19 → 2.0.0

package/src/cli.ts

@@ -0,0 +1,84 @@
+import meow from "meow";
+
+import { name as pkgName, version as pkgVersion } from "../package.json";
+import { createSliceMachineInitProcess } from "./SliceMachineInitProcess";
+
+const cli = meow(
+	`
+Prismic Slice Machine Init CLI
+
+DOCUMENTATION
+  https://prismic.io/docs
+
+VERSION
+  ${pkgName}@${pkgVersion}
+
+USAGE
+  $ npx @slicemachine/init
+
+OPTIONS
+  --repository, -r        Specify a Prismic repository to use
+
+  --no-push               For starters, prevent anything from being pushed
+  --no-push-slices        For starters, prevent slices from being pushed
+  --no-push-custom-types  For starters, prevent custom types from being pushed
+  --no-push-documents     For starters, prevent documents from being pushed
+
+  --help, -h              Display CLI help
+  --version, -v           Display CLI version
+`,
+	{
+		importMeta: import.meta,
+		flags: {
+			repository: {
+				type: "string",
+				alias: "r",
+			},
+			push: {
+				type: "boolean",
+				default: true,
+			},
+			pushSlices: {
+				type: "boolean",
+				default: true,
+			},
+			pushCustomTypes: {
+				type: "boolean",
+				default: true,
+			},
+			pushDocuments: {
+				type: "boolean",
+				default: true,
+			},
+			help: {
+				type: "boolean",
+				alias: "h",
+				default: false,
+			},
+			version: {
+				type: "boolean",
+				alias: "v",
+				default: false,
+			},
+		},
+		description: false,
+		autoHelp: false,
+		autoVersion: false,
+		allowUnknownFlags: false,
+	},
+);
+
+if (cli.flags.help) {
+	cli.showHelp();
+} else if (cli.flags.version) {
+	// eslint-disable-next-line no-console
+	console.log(`${pkgName}@${pkgVersion}`);
+	process.exit(0);
+} else {
+	const initProcess = createSliceMachineInitProcess({
+		...cli.flags,
+		input: cli.input,
+	});
+
+	initProcess.run();
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+// Those contants should be unique to the init script, if they are needed elsewhere then they should be extracted to the manager
+export const START_SCRIPT_KEY = "slicemachine";
+export const START_SCRIPT_VALUE = "start-slicemachine";

package/src/index.ts

@@ -1,129 +1,5 @@
-import { ApplicationMode } from "@slicemachine/client";
-import Prismic from "@slicemachine/core/build/prismic";
-import Tracker from "./utils/tracker";
-import {
-  installRequiredDependencies,
-  validatePkg,
-  chooseOrCreateARepository,
-  loginOrBypass,
-  configureProject,
-  displayFinalMessage,
-  detectFramework,
-  installLib,
-  sendStarterData,
-  setVersion,
-} from "./steps";
-import {
-  findArgument,
-  findFlag,
-  logs,
-  getApplicationMode,
-  InitClient,
-} from "./utils";
-import { Models } from "@slicemachine/core";
-
-async function init() {
-  const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const mode: ApplicationMode =
-    getApplicationMode(findArgument(process.argv, "mode")) ||
-    ApplicationMode.PROD;
-  const lib: string | undefined = findArgument(process.argv, "library");
-  const branch: string | undefined = findArgument(process.argv, "branch");
-  const isTrackingAvailable: boolean =
-    findArgument(process.argv, "tracking") !== "false";
-  const preSelectedRepository: string | undefined = findArgument(
-    process.argv,
-    "repository"
-  );
-  const pushDocuments = !findFlag(process.argv, "no-docs");
-
-  Tracker.get().initialize(
-    process.env.PUBLIC_SM_INIT_SEGMENT_KEY ||
-      "JfTfmHaATChc4xueS7RcCBsixI71dJIJ",
-    isTrackingAvailable
-  );
-
-  void Tracker.get().trackInitStart(preSelectedRepository);
-
-  // initializing the client with what we have for now.
-  const client = new InitClient(
-    mode,
-    null,
-    Prismic.PrismicSharedConfigManager.getAuth()
-  );
-
-  console.log(
-    logs.purple(
-      "You're about to configure Slicemachine... Press ctrl + C to cancel"
-    )
-  );
-
-  // verify package.json file exist
-  validatePkg(cwd);
-
-  const user = await loginOrBypass(client);
-
-  Tracker.get().identifyUser(user.shortId, user.intercomHash);
-  void Tracker.get().trackInitIdentify();
-
-  // detect the framework used by the project
-  const frameworkResult = await detectFramework(cwd);
-
-  // select the repository used with the project.
-  const repository = await chooseOrCreateARepository(
-    client,
-    cwd,
-    frameworkResult.value,
-    preSelectedRepository
-  );
-
-  Tracker.get().setRepository(repository);
-  client.updateRepository(repository);
-
-  const sliceLibPath = lib ? await installLib(cwd, lib, branch) : undefined;
-
-  const wasStarter = await sendStarterData(client, cwd, pushDocuments); // will be false if no sm.json is found
-
-  // configure the SM.json file and the json package file of the project..
-  await configureProject(
-    client,
-    cwd,
-    repository,
-    frameworkResult,
-    sliceLibPath,
-    isTrackingAvailable
-  );
-
-  // Install the required dependencies in the project.
-  await installRequiredDependencies(
-    cwd,
-    frameworkResult.value,
-    wasStarter,
-    frameworkResult.version
-  );
-
-  setVersion(cwd);
-
-  // Info about tracking
-  if (isTrackingAvailable) {
-    logs.writeInfo(
-      "We use tracking tools to improve user experience. Learn more: https://prismic.io/docs/slice-machine#tracking"
-    );
-  }
-
-  // Ask the user to run slice-machine.
-  displayFinalMessage(cwd, wasStarter, repository, client.apisEndpoints.Wroom);
-}
-
-init()
-  .then(() => {
-    process.exit(0);
-  })
-  .catch(async (error) => {
-    if (error instanceof Error) logs.writeError(error.message);
-    else console.error(error);
-    await Tracker.get().trackInitEndFail(
-      Models.Frameworks.none,
-      "Failed to initialise Slice Machine."
-    );
-  });
+export type { SliceMachineInitProcessOptions } from "./SliceMachineInitProcess";
+export {
+	createSliceMachineInitProcess,
+	SliceMachineInitProcess,
+} from "./SliceMachineInitProcess";

package/src/lib/assertExists.ts

@@ -0,0 +1,9 @@
+// TypeScript cannot use arrow functions for assertions
+export function assertExists<T>(
+	value: T,
+	message: string,
+): asserts value is NonNullable<T> {
+	if (value == undefined) {
+		throw new Error(message);
+	}
+}

package/src/lib/framework.ts

@@ -0,0 +1,155 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import semver from "semver";
+
+import { version as pkgVersion } from "../../package.json";
+
+export type Framework = {
+	/**
+	 * Framework's human readable name.
+	 */
+	name: string;
+
+	/**
+	 * Framework's name sent to Prismic
+	 */
+	prismicName: string;
+
+	/**
+	 * A link to the Prismic documentation for the framework
+	 */
+	prismicDocumentation: string;
+
+	/**
+	 * Package name of the adapter responsible for this framework
+	 */
+	adapterName: string;
+
+	/**
+	 * A package name/semver range map defining framework compatibility
+	 * requirements.
+	 *
+	 * Project should match all entries to be considered compatible.
+	 */
+	compatibility: Record<string, string>;
+
+	/**
+	 * A package name/semver range map defining development dependencies to be
+	 * installed. Typically Slice Machine and the framework's adapter.
+	 *
+	 * @remarks
+	 * Dependencies required to work with the framework (e.g. `@prismicio/next`
+	 * for Next.js) should not be defined here. Those are to be defined by the
+	 * adapter.
+	 */
+	devDependencies: Record<string, string>;
+};
+
+const isPrerelease =
+	semver.prerelease(pkgVersion) !== null && process.env.NODE_ENV !== "test";
+
+const DEFAULT_DEV_DEPENDENCIES: Record<string, string> = {
+	"slice-machine-ui": isPrerelease ? "alpha" : "latest",
+};
+
+/**
+ * Frameworks we support, orders shouldn't matter much but is respected (the
+ * higher it is the more priority it has in case multiple matches)
+ */
+export const FRAMEWORKS: Record<string, Framework> = {
+	"nuxt-2": {
+		name: "Nuxt 2",
+		prismicName: "nuxt-2",
+		prismicDocumentation: "https://prismic.dev/init/nuxt-2",
+		adapterName: "@slicemachine/adapter-nuxt2",
+		compatibility: {
+			nuxt: "^2.0.0",
+		},
+		devDependencies: {
+			...DEFAULT_DEV_DEPENDENCIES,
+			"@slicemachine/adapter-nuxt2": isPrerelease ? "alpha" : "latest",
+		},
+	},
+	"nuxt-3": {
+		name: "Nuxt 3",
+		prismicName: "nuxt-3",
+		prismicDocumentation: "https://prismic.dev/init/nuxt-3",
+		adapterName: "@slicemachine/adapter-nuxt",
+		compatibility: {
+			nuxt: "^3.0.0",
+		},
+		devDependencies: {
+			...DEFAULT_DEV_DEPENDENCIES,
+			"@slicemachine/adapter-nuxt": isPrerelease ? "alpha" : "latest",
+		},
+	},
+	"next-11-13": {
+		name: "Next.js 11-13",
+		prismicName: "next-11-13",
+		prismicDocumentation: "https://prismic.dev/init/next-11-13",
+		adapterName: "@slicemachine/adapter-next",
+		compatibility: {
+			next: "^11.0.0 || ^12.0.0 || ^13.0.0",
+		},
+		devDependencies: {
+			...DEFAULT_DEV_DEPENDENCIES,
+			"@slicemachine/adapter-next": isPrerelease ? "alpha" : "latest",
+		},
+	},
+} as const;
+
+/**
+ * Universal package used when framework is not supported.
+ */
+export const UNIVERSAL: Framework = {
+	name: "universal (no framework)",
+	prismicName: "universal",
+	prismicDocumentation: "https://prismic.dev/init/universal",
+	adapterName: "@slicemachine/adapter-universal",
+	compatibility: {},
+	devDependencies: {
+		...DEFAULT_DEV_DEPENDENCIES,
+		"@slicemachine/adapter-universal": isPrerelease ? "alpha" : "latest",
+	},
+};
+
+export const detectFramework = async (cwd: string): Promise<Framework> => {
+	const path = join(cwd, "package.json");
+
+	let allDependencies: Record<string, string>;
+	try {
+		const pkg = JSON.parse(await readFile(path, "utf-8"));
+
+		allDependencies = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+		};
+	} catch (error) {
+		throw new Error(
+			`Failed to read project's \`package.json\` at \`${path}\``,
+			{ cause: error },
+		);
+	}
+
+	return (
+		Object.values(FRAMEWORKS).find((framework) => {
+			return Object.entries(framework.compatibility).every(([pkg, range]) => {
+				if (pkg in allDependencies) {
+					try {
+						// Determine lowest version possibly in use
+						const minimumVersion = semver.minVersion(allDependencies[pkg]);
+
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						return semver.satisfies(minimumVersion!, range);
+					} catch (error) {
+						// We assume unconventional tags, `latest`, `beta`, `dev` matches the framework
+						return true;
+					}
+				}
+
+				return false;
+			});
+		}) || UNIVERSAL
+	);
+};

package/src/lib/getExecuteCommand.ts

@@ -0,0 +1,9 @@
+import { parseNix } from "@antfu/ni";
+import { PackageManager } from "@slicemachine/manager";
+
+export const getExecuteCommand = async (args: {
+	agent: PackageManager;
+	script: string;
+}): Promise<string> => {
+	return (await parseNix(args.agent, [args.script])) || `npx ${args.script}`;
+};

package/src/lib/getRunScriptCommand.ts

@@ -0,0 +1,9 @@
+import { parseNr } from "@antfu/ni";
+import { PackageManager } from "@slicemachine/manager";
+
+export const getRunScriptCommand = async (args: {
+	agent: PackageManager;
+	script: string;
+}): Promise<string> => {
+	return (await parseNr(args.agent, [args.script])) || `npm run ${args.script}`;
+};

package/src/lib/listr.ts

@@ -0,0 +1,15 @@
+// @ts-expect-error - @types package not available
+import UpdateRenderer from "@lihbr/listr-update-renderer";
+import Listr from "listr";
+
+type ListrArgs = [tasks: Listr.ListrTask[], options?: Listr.ListrOptions];
+
+export const listr = (...[tasks, options]: ListrArgs): Listr => {
+	return new Listr(tasks, { renderer: UpdateRenderer, ...options });
+};
+
+export const listrRun = async (
+	...[tasks, options]: ListrArgs
+): Promise<void> => {
+	return listr(tasks, options).run();
+};

package/src/lib/prompt.ts

@@ -0,0 +1,27 @@
+import prompts from "prompts";
+
+type promptArgs<
+	TValue = unknown,
+	TProperty extends string = string,
+> = prompts.PromptObject<TProperty> & {
+	// Method is available, cf. docs
+	onRender?: (this: { msg: string; value?: TValue; initial?: TValue }) => void;
+};
+
+export const prompt = async <TReturn, TProperty extends string = string>(
+	question: promptArgs<TReturn, TProperty>,
+): Promise<Record<TProperty, TReturn>> => {
+	const answers: Record<TProperty, TReturn> = await prompts<TProperty>(
+		question,
+	);
+
+	if (!Object.keys(answers).length) {
+		process.exit(130);
+	}
+
+	// Clear prompt line, clean recap are done manually
+	process.stdout.moveCursor?.(0, -1);
+	process.stdout.clearLine?.(1);
+
+	return answers;
+};

package/src/lib/repositoryDomain.ts

@@ -0,0 +1,219 @@
+const abc123 = `abcdefghijklmnopqrstuvwxyz0123456789`;
+
+// 11 characters long or less adjectives
+const ADJECTIVES = [
+	"adorable",
+	"beautiful",
+	"charming",
+	"cloudy",
+	"delightful",
+	"focused",
+	"honest",
+	"inspiring",
+	"lovable",
+	"melodious",
+	"pleasant",
+	"pretty",
+	"shiny",
+	"sugary",
+	"tall",
+	"valliant",
+].filter((adjective) => adjective.length <= 11);
+
+// 11 characters long or less bakeries
+const BAKERIES = [
+	"baguette",
+	"briouat",
+	"crepe",
+	"croissant",
+	"donut",
+	"eclair",
+	"flaons",
+	"kolompeh",
+	"macaron",
+	"paste",
+	"pretzel",
+	"rustico",
+	"semla",
+	"strudel",
+	"taiyaki",
+	"toast",
+].filter((bakery) => bakery.length <= 11);
+
+const pickRandom = (arrOrString: string | string[]): string => {
+	return arrOrString[Math.floor(Math.random() * arrOrString.length)];
+};
+
+const randomString = (length: number): string => {
+	let result = "";
+
+	for (let i = 0; i < length; i++) {
+		result += pickRandom(abc123);
+	}
+
+	return result;
+};
+
+export const getRandomRepositoryDomain = (): string => {
+	return formatRepositoryDomain(
+		`${pickRandom(ADJECTIVES)}-${pickRandom(BAKERIES)}-${randomString(6)}`,
+	);
+};
+
+export const formatRepositoryDomain = (rawDomain: string): string => {
+	// Lowercase anything
+	let domain = rawDomain.toLowerCase();
+
+	/**
+	 * Replace whitespaces and underscores with hyphens
+	 */
+	domain = domain.replace(/\s/g, "-").replace(/_/g, "-");
+
+	/**
+	 * Replace not allowed characters
+	 *
+	 * @see https://regex101.com/r/f2Hr0k/1
+	 */
+	domain = domain.replace(/[^a-z0-9-]/g, "");
+
+	/**
+	 * Trim leading and trailing hyphens
+	 *
+	 * @see https://regex101.com/r/ivngfc/1
+	 */
+	domain = domain.replace(/(^-+)|(-+$)/g, "");
+
+	/**
+	 * Replace multi hyphens
+	 *
+	 * @see https://regex101.com/r/t9qxh0/1
+	 */
+	domain = domain.replace(/-{2,}/g, "-");
+
+	return domain;
+};
+
+const isFormattedRepositoryDomain = (
+	maybeFormattedRepositoryDomain: string,
+): boolean => {
+	return (
+		maybeFormattedRepositoryDomain ===
+		formatRepositoryDomain(maybeFormattedRepositoryDomain)
+	);
+};
+
+const assertFormattedRepositoryDomain = (
+	maybeFormattedRepositoryDomain: string,
+	caller: string,
+): void => {
+	if (!isFormattedRepositoryDomain(maybeFormattedRepositoryDomain)) {
+		throw new TypeError(
+			`\`${caller}()\` can only validate formatted repository domains, use the \`formatRepositoryDomain()\` first.`,
+		);
+	}
+};
+
+export const ValidationErrors = {
+	LessThan4: "LessThan4",
+	MoreThan30: "MoreThan30",
+	AlreadyExists: "AlreadyExists",
+} as const;
+type ValidationErrors =
+	(typeof ValidationErrors)[keyof typeof ValidationErrors];
+
+type ValidateRepositoryDomainArgs = { domain: string };
+type ValidateRepositoryDomainReturnType = Record<
+	Exclude<ValidationErrors, "AlreadyExists"> | "hasErrors",
+	boolean
+>;
+export const validateRepositoryDomain = (
+	args: ValidateRepositoryDomainArgs,
+): ValidateRepositoryDomainReturnType => {
+	assertFormattedRepositoryDomain(args.domain, "validateRepositoryDomain");
+
+	const errors: Record<Exclude<ValidationErrors, "AlreadyExists">, boolean> = {
+		/**
+		 * Checks non [a-z] first character
+		 *
+		 * @see https://regex101.com/r/OBZ6UH/1
+		 */
+		[ValidationErrors.LessThan4]: args.domain.length < 4,
+		[ValidationErrors.MoreThan30]: args.domain.length > 30,
+	};
+
+	return {
+		...errors,
+		hasErrors: Object.values(errors).some(Boolean),
+	};
+};
+
+type ValidateRepositoryDomainAndAvailabilityArgs = {
+	domain: string;
+	existsFn: (domain: string) => boolean | Promise<boolean>;
+};
+type ValidateRepositoryDomainAndAvailabilityReturnType = Record<
+	ValidationErrors | "hasErrors",
+	boolean
+>;
+export const validateRepositoryDomainAndAvailability = async (
+	args: ValidateRepositoryDomainAndAvailabilityArgs,
+): Promise<ValidateRepositoryDomainAndAvailabilityReturnType> => {
+	assertFormattedRepositoryDomain(
+		args.domain,
+		"validateRepositoryDomainAndAvailability",
+	);
+
+	const errors = validateRepositoryDomain(args);
+
+	if (!errors.hasErrors && (await args.existsFn(args.domain))) {
+		return {
+			...errors,
+			[ValidationErrors.AlreadyExists]: true,
+			hasErrors: true,
+		};
+	}
+
+	return {
+		...errors,
+		[ValidationErrors.AlreadyExists]: false,
+	};
+};
+
+type GetErrorMessageForRepositoryDomainValidationArgs = {
+	validation:
+		| ValidateRepositoryDomainReturnType
+		| ValidateRepositoryDomainAndAvailabilityReturnType;
+	displayDomain?: string;
+};
+export const getErrorMessageForRepositoryDomainValidation = (
+	args: GetErrorMessageForRepositoryDomainValidationArgs,
+): string | null => {
+	if (args.validation.hasErrors) {
+		const formattedErrors: string[] = [];
+
+		if (args.validation.LessThan4) {
+			formattedErrors.push("must be 4 characters long or more");
+		}
+		if (args.validation.MoreThan30) {
+			formattedErrors.push("must be 30 characters long or less");
+		}
+		if (
+			ValidationErrors.AlreadyExists in args.validation &&
+			args.validation.AlreadyExists
+		) {
+			formattedErrors.push("is already taken");
+		}
+
+		if (!formattedErrors.length) {
+			formattedErrors.push(
+				`has unhandled errors ${JSON.stringify(args.validation)}`,
+			);
+		}
+
+		return `Repository name${
+			args.displayDomain ? ` ${args.displayDomain}` : ""
+		} ${formattedErrors.join(" and ")}`;
+	}
+
+	return null;
+};

package/.depcheckrc

@@ -1,4 +0,0 @@
-ignores: [
-  "@types/jest"
-]
-skip - missing: true

package/.eslintignore

@@ -1,3 +0,0 @@
-build
-node_modules
-tests