@prismicio/manager 0.0.1

package/src/auth/createPrismicAuthManager.ts

@@ -0,0 +1,11 @@
+import { PrismicAuthManager } from "./PrismicAuthManager";
+
+type CreatePrismicAuthManager = ConstructorParameters<
+	typeof PrismicAuthManager
+>[0];
+
+export const createPrismicAuthManager = (
+	args?: CreatePrismicAuthManager,
+): PrismicAuthManager => {
+	return new PrismicAuthManager(args);
+};

package/src/auth/createPrismicAuthManagerMiddleware.ts

@@ -0,0 +1,79 @@
+import { parseSetCookie, type SetCookie } from "cookie";
+import {
+	createEvent,
+	createRouter,
+	defineNodeMiddleware,
+	eventHandler,
+	NodeMiddleware,
+	readBody,
+} from "h3";
+import * as z from "zod";
+
+import { decode } from "../lib/decode";
+
+import { PrismicAuthManager } from "./PrismicAuthManager";
+
+const PrismicAuthResponseSchema = z.object({
+	email: z.string(),
+	cookies: z.array(z.string()),
+});
+
+export type PrismicAuthCheckStatusResponse =
+	| {
+			status: "ok";
+			shortId: string;
+	  }
+	| {
+			status: "pending";
+	  };
+
+export type CreatePrismicAuthManagerMiddlewareArgs = {
+	prismicAuthManager: PrismicAuthManager;
+	onLoginCallback?: () => void | Promise<void>;
+};
+
+export const createPrismicAuthManagerMiddleware = (
+	args: CreatePrismicAuthManagerMiddlewareArgs,
+): NodeMiddleware => {
+	const router = createRouter();
+
+	// Route called by the remote Prismic login page on successful login.
+	router.post(
+		"/",
+		eventHandler(async (event) => {
+			const body = await readBody(event);
+			const { value, error } = decode(PrismicAuthResponseSchema, body);
+
+			if (error) {
+				throw new Error(`Invalid auth payload: ${error.errors.join(", ")}`);
+			}
+
+			const token = value.cookies
+				.map((c: string) => parseSetCookie(c))
+				.find((c: SetCookie) => c.name === "prismic-auth")?.value;
+
+			if (!token) {
+				throw new Error("No token found in cookies");
+			}
+
+			await args.prismicAuthManager.login({
+				email: value.email,
+				token: token,
+			});
+
+			if (args.onLoginCallback) {
+				await args.onLoginCallback();
+			}
+
+			return {};
+		}),
+	);
+
+	return defineNodeMiddleware(async (req, res) => {
+		const event = createEvent(req, res);
+
+		await router.handler(event);
+
+		res.end();
+	});
+};

package/src/constants/API_ENDPOINTS.ts

@@ -0,0 +1,106 @@
+import { addTrailingSlash } from "../lib/trailingSlash";
+
+import { APPLICATION_MODE } from "./APPLICATION_MODE";
+
+export type APIEndpoints = {
+	PrismicWroom: string;
+	PrismicLegacyAuthenticationApi: string;
+	PrismicLegacyCustomTypesApi: string;
+	PrismicLegacyUserApi: string;
+	PrismicLegacyAclApi: string;
+	PrismicLegacySliceMachineApi: string;
+};
+
+export const API_ENDPOINTS: APIEndpoints = (() => {
+	switch (process.env.PRISMIC_ENV) {
+		case APPLICATION_MODE.Development: {
+			const apiEndpoints = {
+				PrismicWroom: addTrailingSlash(process.env.wroom_endpoint),
+				PrismicLegacyAuthenticationApi: addTrailingSlash(
+					process.env.legacy_authentication_api_endpoint,
+				),
+				PrismicLegacyCustomTypesApi: addTrailingSlash(
+					process.env.legacy_custom_types_api_endpoint,
+				),
+				PrismicLegacyUserApi: addTrailingSlash(
+					process.env.legacy_user_api_endpoint,
+				),
+				PrismicLegacyAclApi: addTrailingSlash(
+					process.env.legacy_acl_api_endpoint,
+				),
+				PrismicLegacySliceMachineApi: addTrailingSlash(
+					process.env.legacy_slice_machine_api_endpoint,
+				),
+			};
+
+			const missingAPIEndpoints = Object.keys(apiEndpoints).filter((key) => {
+				return !apiEndpoints[key as keyof typeof apiEndpoints];
+			});
+
+			if (missingAPIEndpoints.length > 0) {
+				console.error(
+					`You are running the command in development mode (PRISMIC_ENV=${
+						APPLICATION_MODE.Development
+					}) where API endpoints are configured via environment variables.
+
+The following endpoints were not configured: ${missingAPIEndpoints.join(", ")}.
+
+Configure them before continuing.`,
+				);
+
+				process.exit(1);
+			}
+
+			console.warn(`You are running the command in development mode (PRISMIC_ENV=${
+				APPLICATION_MODE.Development
+			}).
+
+The following API endpoints were configured via environment variables:
+${Object.entries(apiEndpoints)
+	.map(([name, endpoint]) => `  - ${name}: ${endpoint}`)
+	.join("\n")}
+
+These endpoints are different than Prismic's normal endpoints and are not trusted.
+
+If you didn't intend to run the command this way, stop it immediately and unset the PRISMIC_ENV environment variable.`);
+
+			return apiEndpoints as APIEndpoints;
+		}
+
+		case APPLICATION_MODE.Staging: {
+			return {
+				PrismicWroom: "https://wroom.io/",
+				PrismicLegacyAuthenticationApi: "https://auth.wroom.io/",
+				PrismicLegacyCustomTypesApi: "https://customtypes.wroom.io/",
+				PrismicLegacyUserApi: "https://user-service.wroom.io/",
+				PrismicLegacyAclApi: "https://acl-provider.wroom.io/",
+				PrismicLegacySliceMachineApi: "https://sm-api.wroom.io/v1/",
+			};
+		}
+
+		case APPLICATION_MODE.DevTools:
+		case APPLICATION_MODE.MarketingTools:
+		case APPLICATION_MODE.Platform: {
+			return {
+				PrismicWroom: `https://${process.env.PRISMIC_ENV}-wroom.com/`,
+				PrismicLegacyAuthenticationApi: `https://auth.${process.env.PRISMIC_ENV}-wroom.com/`,
+				PrismicLegacyCustomTypesApi: `https://customtypes.${process.env.PRISMIC_ENV}-wroom.com/`,
+				PrismicLegacyUserApi: `https://user-service.${process.env.PRISMIC_ENV}-wroom.com/`,
+				PrismicLegacyAclApi: `https://acl-provider.${process.env.PRISMIC_ENV}-wroom.com/`,
+				PrismicLegacySliceMachineApi: `https://sm-api.${process.env.PRISMIC_ENV}-wroom.com/v1/`,
+			};
+		}
+
+		case APPLICATION_MODE.Production:
+		default: {
+			return {
+				PrismicWroom: "https://prismic.io/",
+				PrismicLegacyAuthenticationApi: "https://auth.prismic.io/",
+				PrismicLegacyCustomTypesApi: "https://customtypes.prismic.io/",
+				PrismicLegacyUserApi: "https://user-service.prismic.io/",
+				PrismicLegacyAclApi: "https://acl-provider.prismic.io/",
+				PrismicLegacySliceMachineApi: "https://sm-api.prismic.io/v1/",
+			};
+		}
+	}
+})();

package/src/constants/API_TOKENS.ts

@@ -0,0 +1,29 @@
+import { APPLICATION_MODE } from "./APPLICATION_MODE";
+
+type APITokens = {
+	SegmentKey: string;
+	AmplitudeKey: string;
+};
+
+export const API_TOKENS: APITokens = (() => {
+	switch (process.env.PRISMIC_ENV) {
+		case APPLICATION_MODE.Development:
+		case APPLICATION_MODE.DevTools:
+		case APPLICATION_MODE.MarketingTools:
+		case APPLICATION_MODE.Platform:
+		case APPLICATION_MODE.Staging:
+			return {
+				SegmentKey: "Ng5oKJHCGpSWplZ9ymB7Pu7rm0sTDeiG",
+				AmplitudeKey: "client-rqVU4xTNaz7F51nBfKRUa0K3qnODiqzh",
+			};
+		case undefined:
+		case "":
+		case APPLICATION_MODE.Production:
+			return {
+				SegmentKey: "cGjidifKefYb6EPaGaqpt8rQXkv5TD6P",
+				AmplitudeKey: "client-JuQQWUPimfKWId3WWU6p8xSkTiFqd1qV",
+			};
+		default:
+			throw new Error(`Unknown application mode "${process.env.PRISMIC_ENV}".`);
+	}
+})();

package/src/constants/APPLICATION_MODE.ts

@@ -0,0 +1,8 @@
+export const APPLICATION_MODE = {
+	Development: "development",
+	DevTools: "dev-tools",
+	MarketingTools: "marketing-tools",
+	Platform: "platform",
+	Staging: "staging",
+	Production: "production",
+} as const;

package/src/constants/PRISMIC_CLI_NPM_PACKAGE_NAME.ts

@@ -0,0 +1 @@
+export const PRISMIC_CLI_NPM_PACKAGE_NAME = "@prismicio/cli";

package/src/constants/PRISMIC_CLI_USER_AGENT.ts

@@ -0,0 +1 @@
+export const PRISMIC_CLI_USER_AGENT = "prismic-cli";

package/src/constants/PRISMIC_CONFIG_FILENAME.ts

@@ -0,0 +1 @@
+export const PRISMIC_CONFIG_FILENAME = "prismic.config.json";

package/src/constants/SLICEMACHINE_CONFIG_FILENAME.ts

@@ -0,0 +1 @@
+export const SLICEMACHINE_CONFIG_FILENAME = "slicemachine.config.json";

package/src/constants/TS_CONFIG_FILENAME.ts

@@ -0,0 +1 @@
+export const TS_CONFIG_FILENAME = "tsconfig.json";

package/src/errors.ts

@@ -0,0 +1,109 @@
+import { HookError } from "@prismicio/plugin-kit";
+
+export class PrismicError extends Error {
+	name = "SMPrismicError";
+}
+export class UnauthorizedError extends PrismicError {
+	name = "SMUnauthorizedError" as const;
+}
+export class UnauthenticatedError extends PrismicError {
+	name = "SMUnauthenticatedError" as const;
+	message = "Authenticate before trying again.";
+}
+export class NotFoundError extends PrismicError {
+	name = "SMNotFoundError" as const;
+}
+export class UnexpectedDataError extends PrismicError {
+	name = "SMUnexpectedDataError" as const;
+}
+export class InternalError extends PrismicError {
+	name = "SMInternalError" as const;
+}
+export class PluginError extends PrismicError {
+	name = "SMPluginError" as const;
+}
+export class PluginHookResultError extends PrismicError {
+	name = "SMPluginHookResultError" as const;
+
+	constructor(errors: HookError[]) {
+		super(
+			`${errors.length} error${
+				errors.length === 1 ? "" : "s"
+			} were returned by one or more plugins.`,
+			{
+				cause: errors,
+			},
+		);
+	}
+}
+export class UnsupportedError extends PrismicError {
+	name = "SMUnsupportedError" as const;
+}
+
+type PrismicErrorNames =
+	| "SMPrismicError"
+	| UnauthorizedError["name"]
+	| UnauthenticatedError["name"]
+	| NotFoundError["name"]
+	| UnexpectedDataError["name"]
+	| InternalError["name"]
+	| PluginError["name"]
+	| PluginHookResultError["name"]
+	| UnsupportedError["name"];
+
+type ShallowPrismicError<TName extends PrismicErrorNames> = Error & {
+	name: TName;
+};
+
+export const isPrismicError = <TName extends PrismicErrorNames>(
+	error: unknown,
+	name?: TName,
+): error is TName extends string ? ShallowPrismicError<TName> : Error => {
+	const isErrorInstance = error instanceof Error;
+
+	return name === undefined
+		? isErrorInstance && error.name.startsWith("SM")
+		: isErrorInstance && error.name === name;
+};
+
+export const isUnauthorizedError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMUnauthorizedError"> => {
+	return isPrismicError(error, "SMUnauthorizedError");
+};
+
+export const isUnauthenticatedError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMUnauthenticatedError"> => {
+	return isPrismicError(error, "SMUnauthenticatedError");
+};
+
+export const isNotFoundError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMNotFoundError"> => {
+	return isPrismicError(error, "SMNotFoundError");
+};
+
+export const isUnexpectedDataError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMUnexpectedDataError"> => {
+	return isPrismicError(error, "SMUnexpectedDataError");
+};
+
+export const isInternalError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMInternalError"> => {
+	return isPrismicError(error, "SMInternalError");
+};
+
+export const isPluginError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMPluginError"> => {
+	return isPrismicError(error, "SMPluginError");
+};
+
+export const isUnsupportedError = (
+	error: unknown,
+): error is ShallowPrismicError<"SMUnsupportedError"> => {
+	return isPrismicError(error, "SMUnsupportedError");
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export type { PrismicManager } from "./managers/PrismicManager";
+export { createPrismicManager } from "./managers/createPrismicManager";
+
+export { PrismicUserProfile } from "./auth/PrismicAuthManager";
+export { PackageManager, PrismicConfig } from "./types";

package/src/lib/DecodeError.ts

@@ -0,0 +1,31 @@
+import * as z from "zod";
+
+type ZodIssue = z.ZodIssue;
+
+type DecodeErrorConstructorArgs<TInput = unknown> = {
+	input: TInput;
+	errors: ZodIssue[];
+};
+
+function formatZodErrors(errors: ZodIssue[]): string[] {
+	return errors.map((err) => {
+		const path = err.path.length > 0 ? ` at ${err.path.join(".")}` : "";
+
+		return `${err.message}${path}`;
+	});
+}
+
+export class DecodeError<TInput = unknown> extends Error {
+	name = "DecodeError";
+	input: TInput;
+	errors: string[];
+
+	constructor(args: DecodeErrorConstructorArgs<TInput>) {
+		const formattedErrors = formatZodErrors(args.errors);
+
+		super(formattedErrors.join(", "));
+
+		this.input = args.input;
+		this.errors = formattedErrors;
+	}
+}

package/src/lib/assertPluginsInitialized.ts

@@ -0,0 +1,11 @@
+import { PluginSystemRunner } from "@prismicio/plugin-kit";
+
+export function assertPluginsInitialized(
+	pluginSystemRunner: PluginSystemRunner | undefined,
+): asserts pluginSystemRunner is NonNullable<typeof pluginSystemRunner> {
+	if (pluginSystemRunner == undefined) {
+		throw new Error(
+			"Plugins have not been initialized. Run `PrismicManager.plugins.prototype.initPlugins()` before re-calling this method.",
+		);
+	}
+}

package/src/lib/castArray.ts

@@ -0,0 +1,3 @@
+export const castArray = <T>(input: T | readonly T[]): T[] => {
+	return Array.isArray(input) ? input : ([input] as T[]);
+};

package/src/lib/decode.ts

@@ -0,0 +1,28 @@
+import * as z from "zod";
+
+import { DecodeError } from "./DecodeError";
+
+export type DecodeReturnType<A, _O, I> =
+	| {
+			value: A;
+			error?: never;
+	  }
+	| {
+			value?: never;
+			error: DecodeError<I>;
+	  };
+
+export function decode<A, O, I>(
+	codec: z.ZodType<A>,
+	input: I,
+): DecodeReturnType<A, O, I> {
+	const parsed = codec.safeParse(input);
+
+	if (parsed.success) {
+		return { value: parsed.data } as DecodeReturnType<A, O, I>;
+	}
+
+	return {
+		error: new DecodeError({ input, errors: parsed.error.issues }),
+	} as DecodeReturnType<A, O, I>;
+}

package/src/lib/decodeHookResult.ts

@@ -0,0 +1,36 @@
+import { CallHookReturnType, HookError } from "@prismicio/plugin-kit";
+import * as z from "zod";
+
+import { DecodeError } from "./DecodeError";
+import { decode } from "./decode";
+
+export const decodeHookResult = <
+	A,
+	_O,
+	I,
+	THookResult extends Awaited<CallHookReturnType>,
+>(
+	codec: z.ZodType<A>,
+	hookResult: THookResult,
+): {
+	data: A[];
+	errors: (HookError | DecodeError<I>)[];
+} => {
+	const data: A[] = [];
+	const errors: DecodeError<I>[] = [];
+
+	for (const dataElement of hookResult.data) {
+		const { value, error } = decode(codec, dataElement);
+
+		if (error) {
+			errors.push(error);
+		} else {
+			data.push(value);
+		}
+	}
+
+	return {
+		data,
+		errors: [...errors, ...hookResult.errors],
+	};
+};

package/src/lib/decodePackageJSON.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+
+import { decode, DecodeReturnType } from "./decode";
+
+/**
+ * A minimally defined schema for package.json files. Only data needed for
+ * version detection is defined.
+ */
+const PackageJSONSchema = z.object({
+	version: z.string(),
+});
+type PackageJSON = z.infer<typeof PackageJSONSchema>;
+
+export const decodePackageJSON = (
+	input: unknown,
+): DecodeReturnType<PackageJSON, PackageJSON, unknown> => {
+	return decode(PackageJSONSchema, input);
+};

package/src/lib/decodePrismicConfig.ts

@@ -0,0 +1,26 @@
+import * as z from "zod";
+
+import { PrismicConfig } from "../types";
+
+import { decode, DecodeReturnType } from "./decode";
+
+const PrismicConfigPluginRegistrationSchema = z.union([
+	z.string(),
+	z.object({
+		resolve: z.string(),
+		options: z.record(z.string(), z.unknown()).optional(),
+	}),
+]);
+
+const PrismicConfigSchema = z.object({
+	repositoryName: z.string(),
+	adapter: PrismicConfigPluginRegistrationSchema,
+	apiEndpoint: z.string().optional(),
+	libraries: z.array(z.string()).optional(),
+});
+
+export const decodePrismicConfig = (
+	input: unknown,
+): DecodeReturnType<PrismicConfig, PrismicConfig, unknown> => {
+	return decode(PrismicConfigSchema, input);
+};

package/src/lib/fetchNPMPackageVersions.ts

@@ -0,0 +1,45 @@
+import fetch from "node-fetch";
+import * as z from "zod";
+
+import { decode } from "./decode";
+
+/**
+ * The Accept header value used when only metadata required for package
+ * installation is needed. The response includes all versions and some of their
+ * metadata.
+ *
+ * @see https://github.com/npm/registry/blob/cfe04736f34db9274a780184d1cdb2fb3e4ead2a/docs/responses/package-metadata.md#package-metadata
+ */
+const NPM_REGISTRY_ABBREVIATED_METADATA_ACCEPT_HEADER =
+	"application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*";
+
+/**
+ * A minimally defined schema for NPM registry package metadata. Only data
+ * needed for version detection is defined.
+ */
+const NPMRegistryPackageMetadataSchema = z.object({
+	versions: z.record(z.string(), z.unknown()),
+});
+
+type FetchNPMPackageVersionsArgs = {
+	packageName: string;
+};
+
+export const fetchNPMPackageVersions = async (
+	args: FetchNPMPackageVersionsArgs,
+): Promise<string[]> => {
+	const res = await fetch(`https://registry.npmjs.org/${args.packageName}`, {
+		headers: {
+			Accept: NPM_REGISTRY_ABBREVIATED_METADATA_ACCEPT_HEADER,
+		},
+	});
+
+	const json = await res.json();
+	const { value, error } = decode(NPMRegistryPackageMetadataSchema, json);
+
+	if (error) {
+		throw new Error(`Invalid NPM registry response.`, { cause: error });
+	}
+
+	return Object.keys(value.versions);
+};

package/src/lib/format.ts

@@ -0,0 +1,34 @@
+import { stripIndent } from "common-tags";
+import prettier from "prettier";
+
+type FormatOptions = {
+	prettier?: prettier.Options;
+	/**
+	 * Determines if a newline is included at the end of the formatted result.
+	 *
+	 * @defaultValue `true`
+	 */
+	includeNewlineAtEnd?: boolean;
+};
+
+export const format = async (
+	source: string,
+	filePath: string,
+	options?: FormatOptions,
+): Promise<string> => {
+	let formatted = stripIndent(source);
+
+	const prettierOptions = await prettier.resolveConfig(filePath);
+
+	formatted = await prettier.format(formatted, {
+		...prettierOptions,
+		filepath: filePath,
+		...(options?.prettier ?? {}),
+	});
+
+	if (options?.includeNewlineAtEnd === false) {
+		formatted.replace(/[\r\n]+$/, "");
+	}
+
+	return formatted;
+};

package/src/lib/installDependencies.ts

@@ -0,0 +1,74 @@
+import { parseNi } from "@antfu/ni";
+import { execaCommand, type ResultPromise, type Options } from "execa";
+
+import { PackageManager } from "../types";
+
+const EXTRA_INSTALL_FLAGS: Record<PackageManager, string[]> = {
+	npm: ["--color=always", "--loglevel=info"],
+	pnpm: [],
+	yarn: [],
+	"yarn@berry": [],
+	"pnpm@6": [],
+	bun: [],
+	deno: [],
+};
+
+type InstallDependenciesArgs = {
+	packageManager: PackageManager;
+	dependencies: Record<string, string>;
+	dev?: boolean;
+	execa?: Options;
+};
+
+type InstallDependenciesReturnType = {
+	execaProcess: ResultPromise;
+};
+
+const resolveCommand = (
+	command: string | { command: string; args: string[] },
+): string => {
+	if (typeof command === "string") {
+		return command;
+	}
+
+	return [command.command, ...command.args].join(" ");
+};
+
+export const installDependencies = async (
+	args: InstallDependenciesArgs,
+): Promise<InstallDependenciesReturnType> => {
+	const commandArgs = Object.entries(args.dependencies).map(
+		([pkg, range]) => `${pkg}@${range}`,
+	);
+
+	if (commandArgs.length && args.dev) {
+		commandArgs.unshift("-D");
+	}
+
+	commandArgs.push(...EXTRA_INSTALL_FLAGS[args.packageManager]);
+
+	const parsedCommand = await parseNi(args.packageManager, commandArgs);
+
+	if (!parsedCommand) {
+		throw new Error(
+			"Failed to begin dependency installation (could not parse command)",
+			{
+				cause: {
+					packageManager: args.packageManager,
+					dependencies: args.dependencies,
+				},
+			},
+		);
+	}
+
+	const command = resolveCommand(parsedCommand);
+
+	const execaProcess = execaCommand(command, {
+		encoding: "utf8",
+		...args.execa,
+	});
+
+	return {
+		execaProcess,
+	};
+};