@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/test.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createSliceMachineManagerMSWHandler = require("./test/createSliceMachineManagerMSWHandler.cjs");
+exports.createSliceMachineManagerMSWHandler = createSliceMachineManagerMSWHandler.createSliceMachineManagerMSWHandler;
+//# sourceMappingURL=test.cjs.map

package/dist/test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/test.js

@@ -0,0 +1,5 @@
+import { createSliceMachineManagerMSWHandler } from "./test/createSliceMachineManagerMSWHandler.js";
+export {
+  createSliceMachineManagerMSWHandler
+};
+//# sourceMappingURL=test.js.map

package/dist/test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import { HookError, SliceMachinePluginOptions } from "@slicemachine/plugin-kit";
+import { VERSION_KIND } from "./constants/VERSION_KIND";
+export type PackageManager = "npm" | "yarn";
+export type PackageChangelog = {
+    currentVersion: string;
+    updateAvailable: boolean;
+    latestNonBreakingVersion: string | null;
+    versions: PackageVersion[];
+};
+export type PackageVersion = {
+    versionNumber: string;
+    releaseNote: string | null;
+    kind: typeof VERSION_KIND[keyof typeof VERSION_KIND] | null;
+};
+/**
+ * A string, object, or instance representing a registered plugin.
+ *
+ * @typeParam TSliceMachinePluginOptions - User-provided options for the plugin.
+ */
+export type SliceMachineConfigPluginRegistration<TSliceMachinePluginOptions extends SliceMachinePluginOptions = SliceMachinePluginOptions> = string | {
+    resolve: string;
+    options?: TSliceMachinePluginOptions;
+};
+/**
+ * Slice Machine configuration from `slicemachine.config.js`.
+ */
+export type SliceMachineConfig = {
+    _latest: string;
+    apiEndpoint?: string;
+    repositoryName: string;
+    localSliceSimulatorURL?: string;
+    libraries?: string[];
+    adapter: SliceMachineConfigPluginRegistration;
+    plugins?: SliceMachineConfigPluginRegistration[];
+};
+export type OnlyHookErrors<THookResult extends {
+    errors: HookError[];
+} | Promise<{
+    errors: HookError[];
+}>> = Pick<Awaited<THookResult>, "errors">;
+export type S3ACL = {
+    uploadEndpoint: string;
+    requiredFormDataFields: Record<string, string>;
+    imgixEndpoint: string;
+};

package/package.json

@@ -0,0 +1,128 @@
+{
+	"name": "@slicemachine/manager",
+	"version": "0.1.1-dev-plugins.3",
+	"description": "Manage all aspects of a Slice Machine project.",
+	"repository": {
+		"type": "git",
+		"url": "ssh://git@github.com/prismicio/slice-machine.git"
+	},
+	"license": "Apache-2.0",
+	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"require": "./dist/index.cjs",
+			"import": "./dist/index.js"
+		},
+		"./client": {
+			"require": "./dist/client.cjs",
+			"import": "./dist/client.js"
+		},
+		"./test": {
+			"require": "./dist/test.cjs",
+			"import": "./dist/test.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"typesVersions": {
+		"*": {
+			"*": [
+				"dist/index.d.ts"
+			],
+			"client": [
+				"dist/client/index.d.ts"
+			],
+			"test": [
+				"dist/test/index.d.ts"
+			]
+		}
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"scripts": {
+		"build": "vite build",
+		"dev": "vite build --watch",
+		"format": "prettier --write .",
+		"lint": "eslint --ext .js,.ts .",
+		"prepare": "npm run build",
+		"size": "size-limit",
+		"test": "npm run lint && npm run unit && npm run build && npm run size",
+		"unit": "vitest run --coverage",
+		"unit:watch": "vitest watch",
+		"depcheck": "depcheck --config=.depcheckrc"
+	},
+	"dependencies": {
+		"@prismicio/custom-types-client": "^1.0.2",
+		"@prismicio/types-internal": "^1.5.3",
+		"@slicemachine/plugin-kit": "0.1.8-dev-plugins.3",
+		"@wooorm/starry-night": "^1.4.2",
+		"analytics-node": "^6.2.0",
+		"cookie": "^0.5.0",
+		"cors": "^2.8.5",
+		"file-type": "^18.0.0",
+		"fp-ts": "^2.13.1",
+		"get-port": "^6.1.2",
+		"h3": "^1.0.2",
+		"hast-util-to-string": "^2.0.0",
+		"io-ts": "^2.2.20",
+		"io-ts-reporters": "^2.0.1",
+		"node-fetch": "^3.3.0",
+		"p-limit": "^4.0.0",
+		"prettier": "^2.8.1",
+		"r19": "^0.1.3",
+		"rc9": "^2.0.0",
+		"rehype-stringify": "^9.0.3",
+		"remark-gfm": "^3.0.1",
+		"remark-parse": "^10.0.1",
+		"remark-rehype": "^10.1.0",
+		"semver": "^7.3.8",
+		"unified": "^10.1.2"
+	},
+	"devDependencies": {
+		"@prismicio/mock": "^0.2.0",
+		"@size-limit/preset-small-lib": "^8.1.0",
+		"@types/analytics-node": "^3.1.9",
+		"@types/cookie": "^0.5.1",
+		"@types/semver": "^7.3.13",
+		"@typescript-eslint/eslint-plugin": "~5.46.1",
+		"@typescript-eslint/parser": "^5.46.1",
+		"@vitest/coverage-c8": "^0.25.8",
+		"eslint": "^8.29.0",
+		"eslint-config-prettier": "^8.5.0",
+		"eslint-plugin-prettier": "^4.2.1",
+		"eslint-plugin-tsdoc": "^0.2.17",
+		"express": "^4.18.2",
+		"memfs": "^3.4.12",
+		"msw": "^0.49.2",
+		"parse-multipart-data": "^1.5.0",
+		"prettier-plugin-jsdoc": "^0.4.2",
+		"puppeteer": "^19.4.1",
+		"rollup-plugin-rename-node-modules": "^1.3.1",
+		"size-limit": "^8.1.0",
+		"typescript": "^4.9.4",
+		"vite": "^4.0.1",
+		"vite-plugin-sdk": "^0.1.0",
+		"vitest": "^0.25.8"
+	},
+	"peerDependencies": {
+		"puppeteer": "^19"
+	},
+	"peerDependenciesMeta": {
+		"puppeteer": {
+			"optional": true
+		}
+	},
+	"engines": {
+		"node": ">=14.15.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"gitHead": "cd69b89d19d6565c187a63a498b18200fa2ba68c"
+}

package/src/auth/PrismicAuthManager.ts

@@ -0,0 +1,403 @@
+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 "node-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]);
+
+			const res = await fetch(url.toString(), {
+				headers: {
+					"User-Agent": SLICE_MACHINE_USER_AGENT,
+				},
+			});
+
+			if (!res.ok) {
+				await this.logout();
+			}
+
+			return res.ok;
+		} 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 Error("Not logged in.");
+	}
+
+	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.");
+			}
+		} 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,
+			},
+		});
+		const json = await res.json();
+
+		if (res.ok) {
+			const { value: profile, error } = decode(PrismicUserProfile, json);
+
+			if (error) {
+				throw new UnexpectedDataError(
+					"Received invalid data from the Prismic user service.",
+				);
+			}
+
+			return profile;
+		} else {
+			throw new InternalError(
+				"Failed to retrieve profile from the Prismic user service.",
+			);
+		}
+	}
+
+	private async _readPersistedAuthState(): Promise<PrismicAuthState> {
+		const authStateFilePath = this._getPersistedAuthStateFilePath();
+
+		let authStateFileContents: string = JSON.stringify({});
+
+		try {
+			authStateFileContents = await fs.readFile(authStateFilePath, "utf8");
+		} catch {
+			// Write a default persisted state if it doesn't already exist.
+
+			const defaultStateFileContents = {
+				...DEFAULT_PERSISTED_AUTH_STATE,
+				cookies: serializeCookies(DEFAULT_PERSISTED_AUTH_STATE.cookies),
+			};
+			authStateFileContents = JSON.stringify(
+				defaultStateFileContents,
+				null,
+				"\t",
+			);
+
+			await fs.mkdir(path.dirname(authStateFilePath), { recursive: true });
+			await fs.writeFile(authStateFilePath, authStateFileContents);
+		}
+
+		const rawAuthState = JSON.parse(authStateFileContents);
+
+		// Decode cookies into a record for convenience.
+		if ("cookies" in rawAuthState) {
+			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,70 @@
+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);
+
+		return await router.handler(event);
+	});
+};