@slicemachine/manager 0.0.0-alpha.dev-new-release-process.1

package/src/auth/PrismicAuthManager.ts

@@ -0,0 +1,412 @@
+import * as t from "io-ts";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as http from "node:http";
+
+import * as h3 from "h3";
+import fetch from "../lib/fetch";
+import cookie from "cookie";
+import cors from "cors";
+import getPort from "get-port";
+
+import { decode } from "../lib/decode";
+import { serializeCookies } from "../lib/serializeCookies";
+
+import { API_ENDPOINTS } from "../constants/API_ENDPOINTS";
+import { SLICE_MACHINE_USER_AGENT } from "../constants/SLICE_MACHINE_USER_AGENT";
+import { createPrismicAuthManagerMiddleware } from "./createPrismicAuthManagerMiddleware";
+import {
+	InternalError,
+	UnauthenticatedError,
+	UnexpectedDataError,
+} from "../errors";
+
+const COOKIE_SEPARATOR = "; ";
+const AUTH_COOKIE_KEY = "prismic-auth";
+const SESSION_COOKIE_KEY = "SESSION";
+
+const PERSISTED_AUTH_STATE_FILE_NAME = ".prismic";
+const DEFAULT_PERSISTED_AUTH_STATE: PrismicAuthState = {
+	base: "https://prismic.io",
+	cookies: {},
+};
+
+const PrismicAuthState = t.intersection([
+	t.type({
+		base: t.string,
+		cookies: t.intersection([
+			t.partial({
+				[AUTH_COOKIE_KEY]: t.string,
+				SESSION: t.string,
+			}),
+			t.record(t.string, t.string),
+		]),
+	}),
+	t.partial({
+		shortId: t.string,
+		intercomHash: t.string,
+		oauthAccessToken: t.string,
+		authUrl: t.string,
+	}),
+]);
+export type PrismicAuthState = t.TypeOf<typeof PrismicAuthState>;
+
+const PrismicUserProfile = t.exact(
+	t.type({
+		userId: t.string,
+		shortId: t.string,
+		intercomHash: t.string,
+		email: t.string,
+		firstName: t.string,
+		lastName: t.string,
+	}),
+);
+export type PrismicUserProfile = t.TypeOf<typeof PrismicUserProfile>;
+
+type PrismicAuthManagerConstructorArgs = {
+	scopedDirectory?: string;
+};
+
+type PrismicAuthManagerLoginArgs = {
+	email: string;
+	cookies: string[];
+};
+
+type PrismicAuthManagerGetLoginSessionInfoReturnType = {
+	port: number;
+	url: string;
+};
+
+type PrismicAuthManagerNodeLoginSessionArgs = {
+	port: number;
+	onListenCallback?: () => void;
+};
+
+type GetProfileForAuthenticationTokenArgs = {
+	authenticationToken: string;
+};
+
+const checkHasAuthenticationToken = (
+	authState: PrismicAuthState,
+): authState is PrismicAuthState & {
+	cookies: Required<
+		Pick<
+			PrismicAuthState["cookies"],
+			typeof AUTH_COOKIE_KEY | typeof SESSION_COOKIE_KEY
+		>
+	>;
+} => {
+	return Boolean(
+		authState.cookies[AUTH_COOKIE_KEY] && authState.cookies[SESSION_COOKIE_KEY],
+	);
+};
+
+const parseCookies = (cookies: string): Record<string, string> => {
+	return cookie.parse(cookies, {
+		// Don't escape any values.
+		decode: (value) => value,
+	});
+};
+
+export class PrismicAuthManager {
+	// TODO: Automatically scope the manager to the current Slice Machine
+	// project? If not, this internal state can be removed.
+	scopedDirectory: string;
+
+	constructor({
+		scopedDirectory = os.homedir(),
+	}: PrismicAuthManagerConstructorArgs = {}) {
+		this.scopedDirectory = scopedDirectory;
+	}
+
+	// TODO: Make the `cookies` argument more explicit. What are these
+	// mysterious cookies?
+	async login(args: PrismicAuthManagerLoginArgs): Promise<void> {
+		const authState = await this._readPersistedAuthState();
+
+		// Set the auth's URL base to the current base at runtime.
+		authState.base = API_ENDPOINTS.PrismicWroom;
+		authState.cookies = {
+			...authState.cookies,
+			...parseCookies(args.cookies.join(COOKIE_SEPARATOR)),
+		};
+
+		if (checkHasAuthenticationToken(authState)) {
+			const authenticationToken = authState.cookies[AUTH_COOKIE_KEY];
+			const profile = await this._getProfileForAuthenticationToken({
+				authenticationToken,
+			});
+
+			authState.shortId = profile.shortId;
+			authState.intercomHash = profile.intercomHash;
+		}
+
+		await this._writePersistedAuthState(authState);
+	}
+
+	async getLoginSessionInfo(): Promise<PrismicAuthManagerGetLoginSessionInfoReturnType> {
+		// Pick a random port, with a preference for historic `5555`
+		const port = await getPort({ port: 5555 });
+
+		const url = new URL(
+			`./dashboard/cli/login?source=slice-machine&port=${port}`,
+			API_ENDPOINTS.PrismicWroom,
+		).toString();
+
+		return {
+			port,
+			url,
+		};
+	}
+
+	async nodeLoginSession(
+		args: PrismicAuthManagerNodeLoginSessionArgs,
+	): Promise<void> {
+		return new Promise<void>(async (resolve) => {
+			// Timeout attempt after 3 minutes
+			const timeout = setTimeout(() => {
+				server.close();
+				throw new Error(
+					"Login timeout, server did not receive a response within a 3-minute delay",
+				);
+			}, 180_000);
+
+			const app = h3.createApp();
+			app.use(h3.fromNodeMiddleware(cors()));
+			app.use(
+				h3.fromNodeMiddleware(
+					createPrismicAuthManagerMiddleware({
+						prismicAuthManager: this,
+						onLoginCallback() {
+							// Cleanup process and resolve
+							clearTimeout(timeout);
+							server.close();
+							resolve();
+						},
+					}),
+				),
+			);
+
+			// Start server
+			const server = http.createServer(h3.toNodeListener(app));
+			await new Promise<void>((resolve) => {
+				server.once("listening", () => {
+					resolve();
+				});
+				server.listen(args.port);
+			});
+
+			if (args.onListenCallback) {
+				args.onListenCallback();
+			}
+		});
+	}
+
+	async logout(): Promise<void> {
+		const authState = await this._readPersistedAuthState();
+
+		// Remove all Prismic cookies, short ID, and Intercom hash
+		// associated with the currently logged in user.
+		authState.cookies = {};
+		authState.shortId = undefined;
+		authState.intercomHash = undefined;
+
+		await this._writePersistedAuthState(authState);
+	}
+
+	async checkIsLoggedIn(): Promise<boolean> {
+		const authState = await this._readPersistedAuthState();
+
+		if (checkHasAuthenticationToken(authState)) {
+			const url = new URL("./validate", API_ENDPOINTS.PrismicAuthentication);
+			url.searchParams.set("token", authState.cookies[AUTH_COOKIE_KEY]);
+
+			let res;
+			try {
+				res = await fetch(url.toString(), {
+					headers: {
+						"User-Agent": SLICE_MACHINE_USER_AGENT,
+					},
+				});
+			} catch (error) {
+				// Noop, we return if `res` is not defined.
+			}
+
+			if (!res || !res.ok) {
+				await this.logout();
+
+				return false;
+			}
+
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	async getAuthenticationCookies(): Promise<
+		PrismicAuthState["cookies"] &
+			Required<
+				Pick<
+					PrismicAuthState["cookies"],
+					typeof AUTH_COOKIE_KEY | typeof SESSION_COOKIE_KEY
+				>
+			>
+	> {
+		const isLoggedIn = await this.checkIsLoggedIn();
+
+		if (isLoggedIn) {
+			const authState = await this._readPersistedAuthState();
+
+			if (checkHasAuthenticationToken(authState)) {
+				return authState.cookies;
+			}
+		}
+
+		throw new UnauthenticatedError();
+	}
+
+	async getAuthenticationToken(): Promise<string> {
+		const cookies = await this.getAuthenticationCookies();
+
+		return cookies[AUTH_COOKIE_KEY];
+	}
+
+	async refreshAuthenticationToken(): Promise<void> {
+		const authState = await this._readPersistedAuthState();
+
+		if (checkHasAuthenticationToken(authState)) {
+			const url = new URL(
+				"./refreshtoken",
+				API_ENDPOINTS.PrismicAuthentication,
+			);
+			url.searchParams.set("token", authState.cookies[AUTH_COOKIE_KEY]);
+
+			const res = await fetch(url.toString(), {
+				headers: {
+					"User-Agent": SLICE_MACHINE_USER_AGENT,
+				},
+			});
+			const text = await res.text();
+
+			if (res.ok) {
+				authState.cookies[AUTH_COOKIE_KEY] = text;
+
+				await this._writePersistedAuthState(authState);
+			} else {
+				throw new InternalError("Failed to refresh authentication token.", {
+					cause: text,
+				});
+			}
+		} else {
+			throw new UnauthenticatedError();
+		}
+	}
+
+	async getProfile(): Promise<PrismicUserProfile> {
+		const authenticationToken = await this.getAuthenticationToken();
+
+		return await this._getProfileForAuthenticationToken({
+			authenticationToken,
+		});
+	}
+
+	private async _getProfileForAuthenticationToken(
+		args: GetProfileForAuthenticationTokenArgs,
+	): Promise<PrismicUserProfile> {
+		const url = new URL("./profile", API_ENDPOINTS.PrismicUser);
+		const res = await fetch(url.toString(), {
+			headers: {
+				Authorization: `Bearer ${args.authenticationToken}`,
+				"User-Agent": SLICE_MACHINE_USER_AGENT,
+			},
+		});
+
+		if (res.ok) {
+			const json = await res.json();
+			const { value: profile, error } = decode(PrismicUserProfile, json);
+
+			if (error) {
+				throw new UnexpectedDataError(
+					"Received invalid data from the Prismic user service.",
+				);
+			}
+
+			return profile;
+		} else {
+			const text = await res.text();
+			throw new InternalError(
+				"Failed to retrieve profile from the Prismic user service.",
+				{
+					cause: text,
+				},
+			);
+		}
+	}
+
+	private async _readPersistedAuthState(): Promise<PrismicAuthState> {
+		const authStateFilePath = this._getPersistedAuthStateFilePath();
+
+		let authStateFileContents: string = JSON.stringify({});
+		let rawAuthState: Record<string, unknown> = {};
+
+		try {
+			authStateFileContents = await fs.readFile(authStateFilePath, "utf8");
+			rawAuthState = JSON.parse(authStateFileContents);
+		} catch {
+			// Write a default persisted state if it doesn't already exist.
+
+			rawAuthState = {
+				...DEFAULT_PERSISTED_AUTH_STATE,
+				cookies: serializeCookies(DEFAULT_PERSISTED_AUTH_STATE.cookies),
+			};
+			authStateFileContents = JSON.stringify(rawAuthState, null, "\t");
+
+			await fs.mkdir(path.dirname(authStateFilePath), { recursive: true });
+			await fs.writeFile(authStateFilePath, authStateFileContents);
+		}
+
+		// Decode cookies into a record for convenience.
+		if (typeof rawAuthState.cookies === "string") {
+			rawAuthState.cookies = parseCookies(rawAuthState.cookies);
+		}
+
+		const { value: authState, error } = decode(PrismicAuthState, rawAuthState);
+
+		if (error) {
+			throw new UnexpectedDataError("Prismic authentication state is invalid.");
+		}
+
+		return authState;
+	}
+
+	private async _writePersistedAuthState(
+		authState: PrismicAuthState,
+	): Promise<void> {
+		const authStateFilePath = this._getPersistedAuthStateFilePath();
+
+		const preparedAuthState = {
+			...authState,
+			cookies: serializeCookies(authState.cookies),
+		};
+
+		try {
+			await fs.writeFile(
+				authStateFilePath,
+				JSON.stringify(preparedAuthState, null, 2),
+			);
+		} catch (error) {
+			throw new InternalError(
+				"Failed to write Prismic authentication state to the file system.",
+				{
+					cause: error,
+				},
+			);
+		}
+	}
+
+	private _getPersistedAuthStateFilePath(): string {
+		return path.resolve(this.scopedDirectory, PERSISTED_AUTH_STATE_FILE_NAME);
+	}
+}

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,72 @@
+import * as t from "io-ts";
+import {
+	createEvent,
+	createRouter,
+	defineNodeMiddleware,
+	eventHandler,
+	NodeMiddleware,
+	readBody,
+} from "h3";
+
+import { decode } from "../lib/decode";
+
+import { PrismicAuthManager } from "./PrismicAuthManager";
+
+const PrismicAuthResponse = t.type({
+	email: t.string,
+	cookies: t.array(t.string),
+});
+type PrismicAuthResponse = t.TypeOf<typeof PrismicAuthResponse>;
+
+export type PrismicAuthCheckStatusResponse =
+	| {
+			status: "ok";
+			shortId: string;
+			intercomHash: 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(PrismicAuthResponse, body);
+
+			if (error) {
+				throw new Error(`Invalid auth payload: ${error.errors.join(", ")}`);
+			}
+
+			await args.prismicAuthManager.login({
+				email: value.email,
+				cookies: value.cookies,
+			});
+
+			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/client/index.ts

@@ -0,0 +1,35 @@
+// This file defines the `@slicemachine/manager/client` export.
+// All exports must be designed for non-Node.js usage.
+
+export { createSliceMachineManagerClient } from "../managers/createSliceMachineManagerClient";
+export type {
+	CreateSliceMachineManagerClientArgs,
+	SliceMachineManagerClient,
+} from "../managers/createSliceMachineManagerClient";
+
+export type {
+	SimulatorManagerReadSliceSimulatorSetupStep,
+	SimulatorManagerReadSliceSimulatorSetupStepsReturnType,
+} from "../managers/simulator/SimulatorManager";
+
+export type { Environment } from "../managers/prismicRepository/types";
+
+export type { SliceMachineManagerPushSliceReturnType } from "../managers/slices/SlicesManager";
+
+export {
+	InternalError,
+	NotFoundError,
+	SliceMachineError,
+	UnauthenticatedError,
+	UnauthorizedError,
+	UnexpectedDataError,
+	isInternalError,
+	isNotFoundError,
+	isPluginError,
+	isSliceMachineError,
+	isUnauthenticatedError,
+	isUnauthorizedError,
+	isUnexpectedDataError,
+} from "../errors";
+
+export { DecodeError } from "../lib/DecodeError";

package/src/constants/API_ENDPOINTS.ts

@@ -0,0 +1,86 @@
+import { addTrailingSlash, removeTrailingSlash } from "../lib/trailingSlash";
+import { APPLICATION_MODE } from "./APPLICATION_MODE";
+
+export type APIEndpoints = {
+	PrismicWroom: string;
+	PrismicAuthentication: string;
+	PrismicModels: string;
+	PrismicUser: string;
+	AwsAclProvider: string;
+	PrismicOembed: string;
+	PrismicUnsplash: string;
+	SliceMachineV1: string;
+};
+
+export const API_ENDPOINTS: APIEndpoints = (() => {
+	switch (process.env.SM_ENV) {
+		case APPLICATION_MODE.Development: {
+			const apiEndpoints = {
+				PrismicWroom: addTrailingSlash(process.env.wroom_endpoint),
+				PrismicAuthentication: addTrailingSlash(
+					process.env.authentication_server_endpoint,
+				),
+				PrismicModels: addTrailingSlash(process.env.customtypesapi_endpoint),
+				PrismicUser: addTrailingSlash(process.env.user_service_endpoint),
+				AwsAclProvider: addTrailingSlash(process.env.acl_provider_endpoint),
+				PrismicOembed: removeTrailingSlash(
+					process.env.oembed_endpoint ?? "https://oembed.wroom.io",
+				),
+				PrismicUnsplash: removeTrailingSlash(
+					process.env.unsplash_endpoint ?? "https://unsplash.wroom.io",
+				),
+				SliceMachineV1: addTrailingSlash(
+					process.env.slice_machine_v1_endpoint ??
+						"https://mc5qopc07a.execute-api.us-east-1.amazonaws.com/v1/",
+				),
+			};
+
+			const missingAPIEndpoints = Object.keys(apiEndpoints).filter((key) => {
+				return !apiEndpoints[key as keyof typeof apiEndpoints];
+			});
+
+			if (missingAPIEndpoints.length > 0) {
+				console.error(
+					`You are running Slice Machine in development mode where API endpoints are configured via environment variables. The following endpoints were not configured: ${missingAPIEndpoints.join(
+						", ",
+					)}. Configure them before continuing.`,
+				);
+
+				process.exit(1);
+			}
+
+			return apiEndpoints as APIEndpoints;
+		}
+
+		case APPLICATION_MODE.Staging: {
+			return {
+				PrismicWroom: "https://wroom.io/",
+				PrismicAuthentication: "https://auth.wroom.io/",
+				PrismicModels: "https://customtypes.wroom.io/",
+				PrismicUser: "https://user-service.wroom.io/",
+				AwsAclProvider:
+					"https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/",
+				PrismicOembed: "https://oembed.wroom.io",
+				PrismicUnsplash: "https://unsplash.wroom.io",
+				SliceMachineV1:
+					"https://mc5qopc07a.execute-api.us-east-1.amazonaws.com/v1/",
+			};
+		}
+
+		case APPLICATION_MODE.Production:
+		default: {
+			return {
+				PrismicWroom: "https://prismic.io/",
+				PrismicAuthentication: "https://auth.prismic.io/",
+				PrismicModels: "https://customtypes.prismic.io/",
+				PrismicUser: "https://user-service.prismic.io/",
+				AwsAclProvider:
+					"https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/",
+				PrismicOembed: "https://oembed.prismic.io",
+				PrismicUnsplash: "https://unsplash.prismic.io",
+				SliceMachineV1:
+					"https://21vvgrh0s6.execute-api.us-east-1.amazonaws.com/v1/",
+			};
+		}
+	}
+})();

package/src/constants/API_TOKENS.ts

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

package/src/constants/APPLICATION_MODE.ts

@@ -0,0 +1,5 @@
+export const APPLICATION_MODE = {
+	Development: "development",
+	Staging: "staging",
+	Production: "production",
+} as const;

package/src/constants/DEFAULT_SLICE_SCREENSHOT_URL.ts

@@ -0,0 +1,6 @@
+/**
+ * The default Slice screenshot URL used when a Slice does not have a local
+ * screenshot.
+ */
+export const DEFAULT_SLICE_SCREENSHOT_URL =
+	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";

package/src/constants/REPOSITORY_NAME_VALIDATION.ts

@@ -0,0 +1,4 @@
+export const REPOSITORY_NAME_VALIDATION = {
+	Min: 4,
+	Max: 63,
+};

package/src/constants/SLICE_MACHINE_CONFIG_FILENAME.ts

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

package/src/constants/SLICE_MACHINE_GITHUB_PACKAGE_NAME.ts

@@ -0,0 +1 @@
+export const SLICE_MACHINE_GITHUB_PACKAGE_NAME = "slice-machine-ui";

package/src/constants/SLICE_MACHINE_GITHUB_REPOSITORY_NAME.ts

@@ -0,0 +1 @@
+export const SLICE_MACHINE_GITHUB_REPOSITORY_NAME = "slice-machine";

package/src/constants/SLICE_MACHINE_GITHUB_REPOSITORY_ORGANIZATION.ts

@@ -0,0 +1 @@
+export const SLICE_MACHINE_GITHUB_REPOSITORY_ORGANIZATION = "prismicio";

package/src/constants/SLICE_MACHINE_NPM_PACKAGE_NAME.ts

@@ -0,0 +1 @@
+export const SLICE_MACHINE_NPM_PACKAGE_NAME = "slice-machine-ui";

package/src/constants/SLICE_MACHINE_USER_AGENT.ts

@@ -0,0 +1 @@
+export const SLICE_MACHINE_USER_AGENT = "slice-machine";

package/src/constants/TS_CONFIG_FILENAME.ts

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

package/src/constants/VERSION_KIND.ts

@@ -0,0 +1,6 @@
+export const VERSION_KIND = {
+	MAJOR: "MAJOR",
+	MINOR: "MINOR",
+	PATCH: "PATCH",
+	FIRST: "FIRST",
+} as const;