@slicemachine/manager 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@slicemachine/manager",
-	"version": "0.1.1-dev-plugins.13",
+	"version": "0.1.1-dev-plugins-validation.1",
 	"description": "Manage all aspects of a Slice Machine project.",
 	"repository": {
 		"type": "git",
@@ -50,34 +50,38 @@
 		"dev": "vite build --watch",
 		"format": "prettier --write .",
 		"lint": "eslint --ext .js,.ts .",
-		"prepare": "npm run build",
+		"//prepare": "npm run build",
 		"size": "size-limit",
 		"test": "npm run lint && npm run types && npm run unit && npm run build && npm run size",
 		"types": "tsc --noEmit",
 		"unit": "vitest run --coverage",
 		"unit:watch": "vitest watch",
-		"depcheck": "depcheck --config=.depcheckrc"
+		"depcheck": "depcheck --config=.depcheckrc",
+		"audit": "better-npm-audit audit -l high -p"
 	},
 	"dependencies": {
+		"@antfu/ni": "^0.20.0",
 		"@prismicio/custom-types-client": "^1.0.2",
 		"@prismicio/types-internal": "^1.5.3",
-		"@slicemachine/plugin-kit": "0.1.8-dev-plugins.13",
-		"@wooorm/starry-night": "^1.4.2",
+		"@slicemachine/plugin-kit": "0.1.8-dev-plugins-validation.1",
+		"@wooorm/starry-night": "^1.6.0",
 		"analytics-node": "^6.2.0",
 		"cookie": "^0.5.0",
 		"cors": "^2.8.5",
-		"file-type": "^18.0.0",
+		"execa": "^7.1.1",
+		"file-type": "^18.2.1",
 		"fp-ts": "^2.13.1",
 		"get-port": "^6.1.2",
-		"h3": "^1.0.2",
+		"h3": "^1.6.0",
 		"hast-util-to-string": "^2.0.0",
 		"io-ts": "^2.2.20",
 		"io-ts-reporters": "^2.0.1",
-		"node-fetch": "^3.3.0",
+		"io-ts-types": "^0.5.19",
+		"node-fetch": "^3.3.1",
 		"p-limit": "^4.0.0",
-		"prettier": "^2.8.1",
-		"r19": "^0.1.6",
-		"rc9": "^2.0.0",
+		"prettier": "^2.8.4",
+		"r19": "0.1.7",
+		"rc9": "^2.0.1",
 		"rehype-stringify": "^9.0.3",
 		"remark-gfm": "^3.0.1",
 		"remark-parse": "^10.0.1",
@@ -87,35 +91,40 @@
 	},
 	"devDependencies": {
 		"@prismicio/mock": "^0.2.0",
-		"@size-limit/preset-small-lib": "^8.1.0",
-		"@types/analytics-node": "^3.1.10",
+		"@size-limit/preset-small-lib": "^8.2.4",
+		"@types/analytics-node": "^3.1.11",
 		"@types/cookie": "^0.5.1",
 		"@types/express": "^4.17.17",
 		"@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",
+		"@typescript-eslint/eslint-plugin": "~5.55.0",
+		"@typescript-eslint/parser": "^5.55.0",
+		"@vitest/coverage-c8": "^0.27.3",
+		"better-npm-audit": "^3.7.3",
+		"eslint": "^8.36.0",
+		"eslint-config-prettier": "^8.7.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",
+		"hook-std": "^3.0.0",
+		"memfs": "^3.4.13",
+		"msw": "^1.1.0",
 		"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"
+		"puppeteer": "^19.7.5",
+		"size-limit": "^8.2.4",
+		"typescript": "^4.9.5",
+		"vite": "^4.1.4",
+		"vite-plugin-sdk": "^0.1.1",
+		"vitest": "^0.27.3"
 	},
 	"peerDependencies": {
+		"msw": "^1.1.0",
 		"puppeteer": "^19"
 	},
 	"peerDependenciesMeta": {
+		"msw": {
+			"optional": true
+		},
 		"puppeteer": {
 			"optional": true
 		}
@@ -126,5 +135,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "e368e5e7b09008aaffdc28bbadaa8a495d7396b9"
+	"gitHead": "be509347c1cfaed23c9b9f714051a38436d4d9de"
 }

package/src/constants/API_TOKENS.ts

@@ -8,11 +8,12 @@ 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:
-			return {
-				// TODO: Sort tracked events in a single source, for now this points only to: https://app.segment.com/prismic/sources/slicejavascript2/settings/keys
-				SegmentKey: "JfTfmHaATChc4xueS7RcCBsixI71dJIJ",
-			};
+			throw new Error(`Unknown application mode "${process.env.SM_ENV}".`);
 	}
 })();

package/src/index.ts

@@ -24,4 +24,4 @@ export {
 
 export { DecodeError } from "./lib/DecodeError";
 
-export type { SliceMachineConfig } from "./types";
+export type { SliceMachineConfig, PackageManager } from "./types";

package/src/lib/decodeSliceMachineConfig.ts

@@ -35,9 +35,5 @@ const SliceMachineConfigCodec = t.intersection([
 export const decodeSliceMachineConfig = (
 	input: unknown,
 ): DecodeReturnType<SliceMachineConfig, SliceMachineConfig, unknown> => {
-	return decode(SliceMachineConfigCodec, input) as DecodeReturnType<
-		SliceMachineConfig,
-		SliceMachineConfig,
-		unknown
-	>;
+	return decode(SliceMachineConfigCodec, input);
 };

package/src/lib/installDependencies.ts

@@ -0,0 +1,59 @@
+import { parseNi } from "@antfu/ni";
+import {
+	ExecaChildProcess,
+	execaCommand,
+	Options as ExacaOptions,
+} from "execa";
+
+import { PackageManager } from "../types";
+
+const EXTRA_INSTALL_FLAGS: Record<PackageManager, string[]> = {
+	npm: ["--color=always", "--loglevel=info"],
+	pnpm: ["--color"], // TODO: Validate that flags are correct
+	yarn: ["--color"],
+	"yarn@berry": ["--color"], // TODO: Validate that flags are correct
+	"pnpm@6": ["--color"], // TODO: Validate that flags are correct
+	bun: ["--color"], // TODO: Validate that flags are correct
+};
+
+type InstallDependenciesArgs = {
+	packageManager: PackageManager;
+	dependencies: Record<string, string>;
+	dev?: boolean;
+	execa?: ExacaOptions;
+};
+
+type InstallDependenciesReturnType = {
+	execaProcess: ExecaChildProcess;
+};
+
+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 command = await parseNi(args.packageManager, commandArgs);
+
+	if (!command) {
+		throw new Error(
+			"Failed to begin dependency installation (could not parse command)",
+		);
+	}
+
+	const execaProcess = execaCommand(command, {
+		encoding: "utf-8",
+		...args.execa,
+	});
+
+	return {
+		execaProcess,
+	};
+};

package/src/lib/locateFileUpward.ts

@@ -16,7 +16,7 @@ export const locateFileUpward = async (
 	filePathOrPaths: string | readonly string[],
 	{
 		startDir = process.cwd(),
-		stopDir = path.resolve("/"),
+		stopDir = path.resolve(startDir, "/"),
 		_originalStartDir,
 	}: LocateFileUpwardConfig = {},
 ): Promise<string> => {

package/src/lib/markdownToHTML.ts

@@ -20,10 +20,13 @@ const createRehypeStarryNight = async (): Promise<
 	const { default: tsxGrammar } = await import(
 		"@wooorm/starry-night/lang/source.tsx.js"
 	);
+	const { default: vueGrammar } = await import(
+		"@wooorm/starry-night/lang/text.html.vue.js"
+	);
 	const { toString } = await import("hast-util-to-string");
 
 	return (options = {}) => {
-		const grammars = options.grammars || [...common, tsxGrammar];
+		const grammars = options.grammars || [...common, tsxGrammar, vueGrammar];
 		const starryNightPromise = createStarryNight(grammars);
 		const prefix = "language-";
 

package/src/managers/SliceMachineManager.ts

@@ -46,7 +46,6 @@ type SliceMachineManagerGetStateReturnType = {
 		packageManager: PackageManager;
 		mockConfig: unknown; // TODO: Remove
 		framework: unknown; // TODO: Remove
-		sliceMachineAPIUrl: string;
 	};
 	libraries: {
 		name: string;
@@ -170,6 +169,7 @@ export class SliceMachineManager {
 			{ sliceMachineConfig, libraries },
 			{ profile, remoteCustomTypes, remoteSlices },
 			customTypes,
+			packageManager,
 		] = await Promise.all([
 			this.project.getSliceMachineConfig().then(async (sliceMachineConfig) => {
 				const libraries = await this._getLibraries(sliceMachineConfig);
@@ -197,6 +197,7 @@ export class SliceMachineManager {
 				}
 			}),
 			this._getCustomTypes(),
+			this.project.detectPackageManager(),
 		]);
 
 		// TODO: SM UI detects if a user is logged out by looking at
@@ -225,12 +226,8 @@ export class SliceMachineManager {
 					localSliceSimulatorURL: sliceMachineConfig.localSliceSimulatorURL,
 				},
 				mockConfig: {},
-				// TODO: Don't hardcode this!
-				packageManager: "npm",
-				// TODO: Don't hardcode this!
+				packageManager,
 				repo: sliceMachineConfig.repositoryName,
-				// TODO: Don't hardcode this!
-				sliceMachineAPIUrl: "http://localhost:9999",
 				intercomHash: profile?.intercomHash,
 				shortId: profile?.shortId,
 			},
@@ -279,7 +276,7 @@ export class SliceMachineManager {
 								]);
 
 								if (model) {
-									const screenshots: typeof components[number]["screenshots"] =
+									const screenshots: (typeof components)[number]["screenshots"] =
 										{};
 									await Promise.all(
 										model.variations.map(async (variation) => {

package/src/managers/createSliceMachineManagerMiddleware.ts

@@ -5,6 +5,7 @@ import {
 	RPCMiddleware,
 	createRPCMiddleware,
 	proceduresFromInstance,
+	OnErrorEventHandler,
 } from "r19";
 
 import { SliceMachineManager } from "./SliceMachineManager";
@@ -42,7 +43,7 @@ const omitProcedures = defineOmits<SliceMachineManager>()([
 ]);
 
 export type SliceMachineManagerMiddleware = RPCMiddleware<
-	ProceduresFromInstance<SliceMachineManager, typeof omitProcedures[number]>
+	ProceduresFromInstance<SliceMachineManager, (typeof omitProcedures)[number]>
 >;
 
 export type SliceMachineManagerProcedures =
@@ -62,6 +63,7 @@ export const getSliceMachineManagerProcedures = (
 
 export type CreateSliceMachineManagerMiddlewareArgs = {
 	sliceMachineManager: SliceMachineManager;
+	onError?: OnErrorEventHandler;
 };
 
 export const createSliceMachineManagerMiddleware = (
@@ -71,5 +73,6 @@ export const createSliceMachineManagerMiddleware = (
 		procedures: getSliceMachineManagerProcedures({
 			sliceMachineManager: args.sliceMachineManager,
 		}),
+		onError: args.onError,
 	});
 };

package/src/managers/prismicRepository/PrismicRepositoryManager.ts

@@ -1,5 +1,6 @@
 import * as t from "io-ts";
 import fetch, { Response } from "node-fetch";
+import { fold } from "fp-ts/Either";
 
 import { decode } from "../../lib/decode";
 import { serializeCookies } from "../../lib/serializeCookies";
@@ -10,11 +11,22 @@ import { API_ENDPOINTS } from "../../constants/API_ENDPOINTS";
 import { BaseManager } from "../BaseManager";
 
 import {
+	AllChangeTypes,
+	BulkBody,
+	ChangeTypes,
+	ClientError,
+	Limit,
+	LimitType,
 	PrismicRepository,
 	PrismicRepositoryRole,
 	PrismicRepositoryUserAgent,
 	PrismicRepositoryUserAgents,
+	RawLimit,
+	TransactionalMergeArgs,
+	TransactionalMergeReturnType,
 } from "./types";
+import { assertPluginsInitialized } from "../../lib/assertPluginsInitialized";
+import { UnauthenticatedError } from "../../errors";
 
 const DEFAULT_REPOSITORY_SETTINGS = {
 	plan: "personal",
@@ -237,6 +249,173 @@ export class PrismicRepositoryManager extends BaseManager {
 		}
 	}
 
+	async pushChanges(
+		args: TransactionalMergeArgs,
+	): Promise<TransactionalMergeReturnType> {
+		assertPluginsInitialized(this.sliceMachinePluginRunner);
+
+		if (!(await this.user.checkIsLoggedIn())) {
+			throw new UnauthenticatedError();
+		}
+
+		try {
+			const allChanges: AllChangeTypes[] = await Promise.all(
+				args.changes.map(async (change) => {
+					if (change.type === "Slice") {
+						switch (change.status) {
+							case "NEW": {
+								const { model } = await this.slices.readSlice({
+									libraryID: change.libraryID,
+									sliceID: change.id,
+								});
+
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.SLICE_INSERT,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "MODIFIED": {
+								const { model } = await this.slices.readSlice({
+									libraryID: change.libraryID,
+									sliceID: change.id,
+								});
+
+								if (!model) {
+									throw Error(`Could not find model  ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.SLICE_UPDATE,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "DELETED":
+								return {
+									id: change.id,
+									payload: { id: change.id },
+									type: ChangeTypes.SLICE_DELETE,
+								};
+						}
+					} else {
+						switch (change.status) {
+							case "NEW": {
+								const { model } = await this.customTypes.readCustomType({
+									id: change.id,
+								});
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.CUSTOM_TYPE_INSERT,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "MODIFIED": {
+								const { model } = await this.customTypes.readCustomType({
+									id: change.id,
+								});
+								if (!model) {
+									throw Error(`Could not find model ${change.id}`);
+								}
+
+								return {
+									type: ChangeTypes.CUSTOM_TYPE_UPDATE,
+									id: change.id,
+									payload: model,
+								};
+							}
+							case "DELETED":
+								return {
+									id: change.id,
+									payload: { id: change.id },
+									type: ChangeTypes.CUSTOM_TYPE_DELETE,
+								};
+						}
+					}
+				}),
+			);
+
+			// Compute the POST body
+			const requestBody: BulkBody = {
+				confirmDeleteDocuments: args.confirmDeleteDocuments,
+				changes: allChanges,
+			};
+
+			const authenticationToken = await this.user.getAuthenticationToken();
+			const sliceMachineConfig = await this.project.getSliceMachineConfig();
+
+			// TODO: API route in consts ends with /customtypes
+			// TODO: move to customtypes client
+			return fetch("https://customtypes.prismic.io/bulk", {
+				body: JSON.stringify(requestBody),
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${authenticationToken}`,
+					"User-Agent": "slice-machine",
+					repository: sliceMachineConfig.repositoryName,
+					"Content-Type": "application/json",
+				},
+			})
+				.then(async (response) => {
+					if (response.status === 204) {
+						return null;
+					}
+
+					return this._decodeLimitOrThrow(
+						await response.json(),
+						response.status,
+						LimitType.SOFT,
+					);
+				})
+				.catch((err: ClientError) => {
+					// Try to decode a limit from the error or throw the original error
+					try {
+						const data: unknown = JSON.parse(err.message);
+
+						return this._decodeLimitOrThrow(data, err.status, LimitType.HARD);
+					} catch {
+						throw err;
+					}
+				});
+		} catch (err) {
+			console.error("An error happened while pushing your changes");
+			console.error(err);
+
+			throw err;
+		}
+	}
+
+	private _decodeLimitOrThrow(
+		potentialLimit: unknown,
+		statusCode: number,
+		limitType: LimitType,
+	): Limit | null {
+		return fold<t.Errors, RawLimit, Limit | null>(
+			() => {
+				const error: ClientError = {
+					status: statusCode,
+					message: `Unable to parse raw limit from ${JSON.stringify(
+						potentialLimit,
+					)}`,
+				};
+				throw error;
+			},
+			(rawLimit: RawLimit) => {
+				const limit = { ...rawLimit, type: limitType };
+
+				return limit;
+			},
+		)(RawLimit.decode(potentialLimit));
+	}
+
 	private async _fetch(args: {
 		url: URL;
 		method?: "GET" | "POST";

package/src/managers/prismicRepository/types.ts

@@ -1,3 +1,4 @@
+import { CustomTypes } from "@prismicio/types-internal";
 import * as t from "io-ts";
 
 export const PrismicRepositoryUserAgent = {
@@ -5,7 +6,7 @@ export const PrismicRepositoryUserAgent = {
 	LegacyZero: "prismic-cli/0",
 } as const;
 export type PrismicRepositoryUserAgents =
-	typeof PrismicRepositoryUserAgent[keyof typeof PrismicRepositoryUserAgent];
+	(typeof PrismicRepositoryUserAgent)[keyof typeof PrismicRepositoryUserAgent];
 
 export const PrismicRepositoryRole = {
 	SuperUser: "SuperUser",
@@ -17,7 +18,7 @@ export const PrismicRepositoryRole = {
 	Readonly: "Readonly",
 } as const;
 export type PrismicRepositoryRoles =
-	typeof PrismicRepositoryRole[keyof typeof PrismicRepositoryRole];
+	(typeof PrismicRepositoryRole)[keyof typeof PrismicRepositoryRole];
 
 export const PrismicRepository = t.type({
 	domain: t.string,
@@ -28,3 +29,102 @@ export const PrismicRepository = t.type({
 	]),
 });
 export type PrismicRepository = t.TypeOf<typeof PrismicRepository>;
+
+export enum ChangeTypes {
+	SLICE_INSERT = "SLICE_INSERT",
+	SLICE_UPDATE = "SLICE_UPDATE",
+	SLICE_DELETE = "SLICE_DELETE",
+	CUSTOM_TYPE_INSERT = "CUSTOM_TYPE_INSERT",
+	CUSTOM_TYPE_UPDATE = "CUSTOM_TYPE_UPDATE",
+	CUSTOM_TYPE_DELETE = "CUSTOM_TYPE_DELETE",
+}
+interface Change {
+	type: ChangeTypes;
+	id: string;
+	payload: Record<string, unknown>;
+}
+interface DeleteChange extends Change {
+	payload: {
+		id: Change["id"];
+	};
+}
+export interface SliceInsertChange extends Change {
+	type: ChangeTypes.SLICE_INSERT;
+	payload: CustomTypes.Widgets.Slices.SharedSlice;
+}
+export interface SliceUpdateChange extends Change {
+	type: ChangeTypes.SLICE_UPDATE;
+	payload: CustomTypes.Widgets.Slices.SharedSlice;
+}
+export interface SliceDeleteChange extends DeleteChange {
+	type: ChangeTypes.SLICE_DELETE;
+}
+export interface CustomTypeInsertChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_INSERT;
+	payload: CustomTypes.CustomType;
+}
+export interface CustomTypeUpdateChange extends Change {
+	type: ChangeTypes.CUSTOM_TYPE_UPDATE;
+	payload: CustomTypes.CustomType;
+}
+export interface CustomTypeDeleteChange extends DeleteChange {
+	type: ChangeTypes.CUSTOM_TYPE_DELETE;
+}
+export type AllChangeTypes =
+	| SliceInsertChange
+	| SliceUpdateChange
+	| SliceDeleteChange
+	| CustomTypeInsertChange
+	| CustomTypeUpdateChange
+	| CustomTypeDeleteChange;
+export interface BulkBody extends Record<string, unknown> {
+	confirmDeleteDocuments: boolean;
+	changes: AllChangeTypes[];
+}
+
+export const RawLimit = t.type({
+	details: t.type({
+		customTypes: t.array(
+			t.type({
+				id: t.string,
+				numberOfDocuments: t.number,
+				url: t.string,
+			}),
+		),
+	}),
+});
+export type RawLimit = t.TypeOf<typeof RawLimit>;
+export enum LimitType {
+	SOFT = "SOFT",
+	HARD = "HARD",
+}
+export type Limit = RawLimit & {
+	type: LimitType;
+};
+
+export interface ClientError {
+	status: number;
+	message: string;
+}
+
+type ChangeStatus = "NEW" | "MODIFIED" | "DELETED";
+
+type CustomTypeChange = {
+	id: string;
+	type: "CustomType";
+	status: ChangeStatus;
+};
+
+type SliceChange = {
+	id: string;
+	type: "Slice";
+	status: ChangeStatus;
+	libraryID: string;
+};
+
+export type TransactionalMergeArgs = {
+	confirmDeleteDocuments: boolean;
+	changes: (CustomTypeChange | SliceChange)[];
+};
+
+export type TransactionalMergeReturnType = Limit | null;