@slicemachine/adapter-next 0.0.1 → 0.0.3

package/src/hooks/slice-create.ts

@@ -3,14 +3,15 @@ import type {
 	SliceCreateHookData,
 	SliceMachineContext,
 } from "@slicemachine/plugin-kit";
-import { generateTypes } from "prismic-ts-codegen";
 import { stripIndent } from "common-tags";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
-import { buildSliceLibraryIndexFileContents } from "../lib/buildSliceLibraryIndexFileContents";
+import { upsertSliceLibraryIndexFile } from "../lib/upsertSliceLibraryIndexFile";
 import { getJSOrTSXFileExtension } from "../lib/getJSOrTSXFileExtension";
 import { pascalCase } from "../lib/pascalCase";
+import { rejectIfNecessary } from "../lib/rejectIfNecessary";
+import { upsertGlobalContentTypes } from "../lib/upsertGlobalContentTypes";
 
 import type { PluginOptions } from "../types";
 
@@ -34,24 +35,24 @@ const createModelFile = async ({ dir, data, helpers, options }: Args) => {
 const createComponentFile = async ({ dir, data, helpers, options }: Args) => {
 	const filePath = path.join(dir, `index.${getJSOrTSXFileExtension(options)}`);
 	const model = data.model;
-	const pascalID = pascalCase(model.id);
+	const pascalName = pascalCase(model.name);
 
 	let contents: string;
 
 	if (options.typescript) {
 		contents = stripIndent`
 			import { SliceComponentProps } from "@prismicio/react";
-			import { ${pascalID}Slice } from "./types";
+			import { ${pascalName}Slice } from "./types";
 
 			/**
-			 * Props for \`${pascalID}\`.
+			 * Props for \`${pascalName}\`.
 			 */
-			export type ${pascalID}Props = SliceComponentProps<${pascalID}Slice>;
+			export type ${pascalName}Props = SliceComponentProps<${pascalName}Slice>;
 
 			/**
 			 * Component for "${model.name}" Slices.
 			 */
-			const ${pascalID} = ({ slice }: ${pascalID}Props): React.Element => {
+			const ${pascalName} = ({ slice }: ${pascalName}Props): React.Element => {
 				return (
 					<section
 						data-slice-type={slice.slice_type}
@@ -62,16 +63,16 @@ const createComponentFile = async ({ dir, data, helpers, options }: Args) => {
 				);
 			};
 
-			export default ${pascalID}
+			export default ${pascalName}
 		`;
 	} else {
 		contents = stripIndent`
 			/**
-			 * @typedef {import("./types").${pascalID}Slice} ${pascalID}Slice
-			 * @typedef {import("@prismicio/react").SliceComponentProps<${pascalID}Slice>} ${pascalID}Props
-			 * @param {${pascalID}Props}
+			 * @typedef {import("./types").${pascalName}Slice} ${pascalName}Slice
+			 * @typedef {import("@prismicio/react").SliceComponentProps<${pascalName}Slice>} ${pascalName}Props
+			 * @param {${pascalName}Props}
 			 */
-			const ${pascalID} = ({ slice }) => {
+			const ${pascalName} = ({ slice }) => {
 				return (
 					<section
 						data-slice-type={slice.slice_type}
@@ -82,7 +83,7 @@ const createComponentFile = async ({ dir, data, helpers, options }: Args) => {
 				);
 			};
 
-			export default ${pascalID};
+			export default ${pascalName};
 		`;
 	}
 
@@ -93,54 +94,28 @@ const createComponentFile = async ({ dir, data, helpers, options }: Args) => {
 	await fs.writeFile(filePath, contents);
 };
 
-const createTypesFile = async ({ dir, data, helpers, options }: Args) => {
-	const filePath = path.join(dir, "types.ts");
-
-	let contents = generateTypes({
-		sharedSliceModels: [data.model],
-	});
-
-	if (options.format) {
-		contents = await helpers.format(contents, filePath);
-	}
-
-	await fs.writeFile(filePath, contents);
-};
-
-const upsertSliceLibraryIndexFile = async ({
-	data,
-	actions,
-	helpers,
-	project,
-	options,
-}: Omit<Args, "dir">) => {
-	const { filePath, contents } = await buildSliceLibraryIndexFileContents({
-		libraryID: data.libraryID,
-		actions,
-		helpers,
-		project,
-		options,
-	});
-
-	await fs.writeFile(filePath, contents);
-};
-
 export const sliceCreate: SliceCreateHook<PluginOptions> = async (
 	data,
 	context,
 ) => {
 	const dir = context.helpers.joinPathFromRoot(
 		data.libraryID,
-		pascalCase(data.model.id),
+		pascalCase(data.model.name),
 	);
 
 	await fs.mkdir(dir, { recursive: true });
 
-	await Promise.allSettled([
-		createModelFile({ dir, data, ...context }),
-		createComponentFile({ dir, data, ...context }),
-		createTypesFile({ dir, data, ...context }),
-	]);
+	rejectIfNecessary(
+		await Promise.allSettled([
+			createModelFile({ dir, data, ...context }),
+			createComponentFile({ dir, data, ...context }),
+		]),
+	);
 
-	await upsertSliceLibraryIndexFile({ data, ...context });
+	rejectIfNecessary(
+		await Promise.allSettled([
+			upsertGlobalContentTypes(context),
+			upsertSliceLibraryIndexFile({ libraryID: data.libraryID, ...context }),
+		]),
+	);
 };

package/src/hooks/slice-delete.ts

@@ -5,8 +5,10 @@ import type {
 } from "@slicemachine/plugin-kit";
 import * as fs from "node:fs/promises";
 
-import { buildSliceLibraryIndexFileContents } from "../lib/buildSliceLibraryIndexFileContents";
 import { pascalCase } from "../lib/pascalCase";
+import { rejectIfNecessary } from "../lib/rejectIfNecessary";
+import { upsertGlobalContentTypes } from "../lib/upsertGlobalContentTypes";
+import { upsertSliceLibraryIndexFile } from "../lib/upsertSliceLibraryIndexFile";
 
 import type { PluginOptions } from "../types";
 
@@ -17,34 +19,22 @@ type Args = {
 const deleteSliceDir = async ({ data, helpers }: Args) => {
 	const dir = helpers.joinPathFromRoot(
 		data.libraryID,
-		pascalCase(data.model.id),
+		pascalCase(data.model.name),
 	);
 
 	await fs.rm(dir, { recursive: true });
 };
 
-const updateSliceLibraryIndexFile = async ({
-	data,
-	actions,
-	helpers,
-	project,
-	options,
-}: Args) => {
-	const { filePath, contents } = await buildSliceLibraryIndexFileContents({
-		libraryID: data.libraryID,
-		actions,
-		helpers,
-		project,
-		options,
-	});
-
-	await fs.writeFile(filePath, contents);
-};
-
 export const sliceDelete: SliceDeleteHook<PluginOptions> = async (
 	data,
 	context,
 ) => {
 	await deleteSliceDir({ data, ...context });
-	await updateSliceLibraryIndexFile({ data, ...context });
+
+	rejectIfNecessary(
+		await Promise.allSettled([
+			upsertGlobalContentTypes(context),
+			upsertSliceLibraryIndexFile({ libraryID: data.libraryID, ...context }),
+		]),
+	);
 };

package/src/hooks/slice-read.ts

@@ -1,8 +1,9 @@
 import type { SliceReadHook } from "@slicemachine/plugin-kit";
-import * as prismicT from "@prismicio/types";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 
+import { isSharedSliceModel } from "../lib/isSharedSliceModel";
 import { readJSONFile } from "../lib/readJSONFile";
-import { pascalCase } from "../lib/pascalCase";
 
 import type { PluginOptions } from "../types";
 
@@ -10,11 +11,40 @@ export const sliceRead: SliceReadHook<PluginOptions> = async (
 	data,
 	{ helpers },
 ) => {
-	const filePath = helpers.joinPathFromRoot(
-		data.libraryID,
-		pascalCase(data.sliceID),
-		"model.json",
-	);
+	const libraryDir = helpers.joinPathFromRoot(data.libraryID);
 
-	return await readJSONFile<prismicT.SharedSliceModel>(filePath);
+	// Ensure the directory exists.
+	await fs.mkdir(libraryDir, { recursive: true });
+
+	const childDirs = await fs.readdir(libraryDir, { withFileTypes: true });
+
+	// Find the first matching model.
+	const [model] = (
+		await Promise.all(
+			childDirs.map(async (childDir) => {
+				if (childDir.isDirectory()) {
+					const modelPath = path.join(libraryDir, childDir.name, "model.json");
+
+					const modelContents = await readJSONFile(modelPath);
+
+					if (
+						isSharedSliceModel(modelContents) &&
+						modelContents.id === data.sliceID
+					) {
+						return modelContents;
+					}
+				}
+			}),
+		)
+	).filter((model): model is NonNullable<typeof model> => Boolean(model));
+
+	if (model) {
+		return {
+			model,
+		};
+	} else {
+		throw new Error(
+			`Did not find a Slice model with ID "${data.sliceID}" in the "${data.libraryID}" Slice Library.`,
+		);
+	}
 };

package/src/hooks/slice-rename.ts

@@ -0,0 +1,44 @@
+import type { SliceRenameHook } from "@slicemachine/plugin-kit";
+import * as fse from "fs-extra";
+
+import { pascalCase } from "../lib/pascalCase";
+import { rejectIfNecessary } from "../lib/rejectIfNecessary";
+import { updateSliceModelFile } from "../lib/updateSliceModelFile";
+import { upsertGlobalContentTypes } from "../lib/upsertGlobalContentTypes";
+import { upsertSliceLibraryIndexFile } from "../lib/upsertSliceLibraryIndexFile";
+
+import type { PluginOptions } from "../types";
+
+export const sliceRename: SliceRenameHook<PluginOptions> = async (
+	data,
+	context,
+) => {
+	const { model: currentModel } = await context.actions.readSliceModel({
+		libraryID: data.libraryID,
+		sliceID: data.model.id,
+	});
+
+	await fse.move(
+		context.helpers.joinPathFromRoot(
+			data.libraryID,
+			pascalCase(currentModel.name),
+		),
+		context.helpers.joinPathFromRoot(
+			data.libraryID,
+			pascalCase(data.model.name),
+		),
+	);
+
+	await updateSliceModelFile({
+		libraryID: data.libraryID,
+		model: data.model,
+		...context,
+	});
+
+	rejectIfNecessary(
+		await Promise.allSettled([
+			upsertGlobalContentTypes(context),
+			upsertSliceLibraryIndexFile({ libraryID: data.libraryID, ...context }),
+		]),
+	);
+};

package/src/hooks/slice-update.ts

@@ -1,58 +1,19 @@
-import type {
-	SliceMachineContext,
-	SliceUpdateHook,
-	SliceUpdateHookData,
-} from "@slicemachine/plugin-kit";
-import { generateTypes } from "prismic-ts-codegen";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
+import type { SliceUpdateHook } from "@slicemachine/plugin-kit";
 
-import { pascalCase } from "../lib/pascalCase";
+import { updateSliceModelFile } from "../lib/updateSliceModelFile";
+import { upsertGlobalContentTypes } from "../lib/upsertGlobalContentTypes";
 
 import type { PluginOptions } from "../types";
 
-type Args = {
-	dir: string;
-	data: SliceUpdateHookData;
-} & SliceMachineContext<PluginOptions>;
-
-const updateModelFile = async ({ dir, data, helpers, options }: Args) => {
-	const filePath = path.join(dir, "model.json");
-
-	let contents = JSON.stringify(data.model);
-
-	if (options.format) {
-		contents = await helpers.format(contents, filePath);
-	}
-
-	await fs.writeFile(filePath, contents);
-};
-
-const updateTypesFile = async ({ dir, data, helpers, options }: Args) => {
-	const filePath = path.join(dir, "types.ts");
-
-	let contents = generateTypes({
-		sharedSliceModels: [data.model],
-	});
-
-	if (options.format) {
-		contents = await helpers.format(contents, filePath);
-	}
-
-	await fs.writeFile(filePath, contents);
-};
-
 export const sliceUpdate: SliceUpdateHook<PluginOptions> = async (
 	data,
 	context,
 ) => {
-	const dir = context.helpers.joinPathFromRoot(
-		data.libraryID,
-		pascalCase(data.model.id),
-	);
+	await updateSliceModelFile({
+		libraryID: data.libraryID,
+		model: data.model,
+		...context,
+	});
 
-	await Promise.allSettled([
-		updateModelFile({ dir, data, ...context }),
-		updateTypesFile({ dir, data, ...context }),
-	]);
+	await upsertGlobalContentTypes(context);
 };

package/src/hooks/sliceLibrary-read.ts

@@ -0,0 +1,44 @@
+import type { SliceLibraryReadHook } from "@slicemachine/plugin-kit";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import { isSharedSliceModel } from "../lib/isSharedSliceModel";
+import { readJSONFile } from "../lib/readJSONFile";
+
+import type { PluginOptions } from "../types";
+
+export const sliceLibraryRead: SliceLibraryReadHook<PluginOptions> = async (
+	data,
+	{ helpers },
+) => {
+	const dir = helpers.joinPathFromRoot(data.libraryID);
+
+	// Ensure the directory exists.
+	await fs.mkdir(dir, { recursive: true });
+
+	const childDirs = await fs.readdir(dir, { withFileTypes: true });
+
+	const sliceIDs: string[] = [];
+	await Promise.all(
+		childDirs.map(async (childDir) => {
+			if (childDir.isDirectory()) {
+				const modelPath = path.join(dir, childDir.name, "model.json");
+
+				try {
+					const modelContents = await readJSONFile(modelPath);
+
+					if (isSharedSliceModel(modelContents)) {
+						sliceIDs.push(modelContents.id);
+					}
+				} catch {
+					// noop
+				}
+			}
+		}),
+	);
+
+	return {
+		id: data.libraryID,
+		sliceIDs: sliceIDs.sort(),
+	};
+};

package/src/lib/isSharedSliceModel.ts

@@ -0,0 +1,14 @@
+import * as prismicT from "@prismicio/types";
+
+export const isSharedSliceModel = (
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+	input: any,
+): input is prismicT.SharedSliceModel => {
+	return (
+		typeof input === "object" &&
+		input !== null &&
+		"type" in input &&
+		input.type === prismicT.CustomTypeModelSliceType.SharedSlice &&
+		typeof input.id === "string"
+	);
+};

package/src/lib/rejectIfNecessary.ts

@@ -0,0 +1,16 @@
+export const rejectIfNecessary = <
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	TPromiseSettledResults extends readonly PromiseSettledResult<any>[],
+>(
+	promiseSettledResults: TPromiseSettledResults,
+): void => {
+	const rejectedReasons = promiseSettledResults
+		.filter(
+			(result): result is PromiseRejectedResult => result.status === "rejected",
+		)
+		.map((result) => result.reason);
+
+	if (rejectedReasons.length > 0) {
+		throw rejectedReasons[0];
+	}
+};

package/src/lib/updateSliceModelFile.ts

@@ -0,0 +1,32 @@
+import { SharedSliceModel } from "@prismicio/types";
+import { SliceMachineContext } from "@slicemachine/plugin-kit";
+import * as fs from "node:fs/promises";
+
+import type { PluginOptions } from "../types";
+import { pascalCase } from "./pascalCase";
+
+type UpdateSliceModelFileArgs = {
+	libraryID: string;
+	model: SharedSliceModel;
+} & SliceMachineContext<PluginOptions>;
+
+export const updateSliceModelFile = async ({
+	libraryID,
+	model,
+	helpers,
+	options,
+}: UpdateSliceModelFileArgs): Promise<void> => {
+	const filePath = helpers.joinPathFromRoot(
+		libraryID,
+		pascalCase(model.name),
+		"model.json",
+	);
+
+	let contents = JSON.stringify(model);
+
+	if (options.format) {
+		contents = await helpers.format(contents, filePath);
+	}
+
+	await fs.writeFile(filePath, contents);
+};

package/src/lib/upsertGlobalContentTypes.ts

@@ -0,0 +1,59 @@
+import type { SliceMachineContext } from "@slicemachine/plugin-kit";
+import { generateTypes } from "prismic-ts-codegen";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import type { PluginOptions } from "../types";
+
+/**
+ * Arguments for `upsertGlobalContentTypes()`.
+ */
+type UpsertGlobalTypesArgs = Pick<
+	SliceMachineContext<PluginOptions>,
+	"actions" | "helpers" | "options"
+>;
+
+/**
+ * Creates a globally accessible TypeScript file containing types representing
+ * the Prismic repository's content.
+ */
+export const upsertGlobalContentTypes = async ({
+	actions,
+	helpers,
+	options,
+}: UpsertGlobalTypesArgs): Promise<void> => {
+	const filePath = helpers.joinPathFromRoot(".slicemachine", "prismicio.d.ts");
+
+	const [customTypeModelDescriptors, sharedSliceModelDescriptors] =
+		await Promise.all([
+			actions.readAllCustomTypeModels(),
+			actions.readAllSliceModels(),
+		]);
+
+	const customTypeModels = customTypeModelDescriptors.map(
+		(customTypeModelDescriptors) => {
+			return customTypeModelDescriptors.model;
+		},
+	);
+	const sharedSliceModels = sharedSliceModelDescriptors.map(
+		(sharedSliceModelDescriptors) => {
+			return sharedSliceModelDescriptors.model;
+		},
+	);
+
+	let contents = generateTypes({
+		customTypeModels,
+		sharedSliceModels,
+		clientIntegration: {
+			includeCreateClientInterface: true,
+			includeContentNamespace: true,
+		},
+	});
+
+	if (options.format) {
+		contents = await helpers.format(contents, filePath);
+	}
+
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, contents);
+};

package/src/lib/{buildSliceLibraryIndexFileContents.ts → upsertSliceLibraryIndexFile.ts}

@@ -1,22 +1,24 @@
 import { SliceMachineContext } from "@slicemachine/plugin-kit";
 import { stripIndent } from "common-tags";
+import * as fs from "node:fs/promises";
 
 import { PluginOptions } from "../types";
 
 import { pascalCase } from "./pascalCase";
 
-type BuildSliceLibraryIndexFileContentsArgs = {
+type UpsertSliceLibraryIndexFileArgs = {
 	libraryID: string;
 } & SliceMachineContext<PluginOptions>;
 
-export const buildSliceLibraryIndexFileContents = async (
-	args: BuildSliceLibraryIndexFileContentsArgs,
-): Promise<{ filePath: string; contents: string }> => {
+export const upsertSliceLibraryIndexFile = async (
+	args: UpsertSliceLibraryIndexFileArgs,
+): Promise<void> => {
 	const filePath = args.helpers.joinPathFromRoot(
 		args.libraryID,
 		args.options.typescript ? "index.ts" : "index.js",
 	);
-	const sliceLibrary = await args.actions.readSliceLibrary({
+
+	const slices = await args.actions.readAllSliceModelsForLibrary({
 		libraryID: args.libraryID,
 	});
 
@@ -24,9 +26,12 @@ export const buildSliceLibraryIndexFileContents = async (
 		import dynamic from 'next/dynamic'
 
 		export const components = {
-			${sliceLibrary.sliceIDs.map(
-				(id) => `${id}: dynamic(() => import('./${pascalCase(id)}')),`,
-			)}
+			${slices.map((slice) => {
+				const id = slice.model.id;
+				const fileName = pascalCase(slice.model.name);
+
+				return `${id}: dynamic(() => import('./${fileName}')),`;
+			})}
 		}
 	`;
 
@@ -34,5 +39,5 @@ export const buildSliceLibraryIndexFileContents = async (
 		contents = await args.helpers.format(contents, filePath);
 	}
 
-	return { filePath, contents };
+	await fs.writeFile(filePath, contents);
 };

package/src/plugin.ts

@@ -3,18 +3,26 @@ import { defineSliceMachinePlugin } from "@slicemachine/plugin-kit";
 import { name as pkgName } from "../package.json";
 import { PluginOptions } from "./types";
 
-import { sliceCreate } from "./hooks/slice-create";
-import { sliceUpdate } from "./hooks/slice-update";
-import { sliceDelete } from "./hooks/slice-delete";
-import { sliceRead } from "./hooks/slice-read";
-import { sliceLibraryRead } from "./hooks/slice-library-read";
+import { customTypeAssetDelete } from "./hooks/customType-asset-delete";
+import { customTypeAssetRead } from "./hooks/customType-asset-read";
+import { customTypeAssetUpdate } from "./hooks/customType-asset-update";
 import { customTypeCreate } from "./hooks/customType-create";
-import { customTypeUpdate } from "./hooks/customType-update";
 import { customTypeDelete } from "./hooks/customType-delete";
+import { customTypeLibraryRead } from "./hooks/customTypeLibrary-read";
 import { customTypeRead } from "./hooks/customType-read";
-import { customTypeLibraryRead } from "./hooks/customType-library-read";
-import { snippetRead } from "./hooks/snippet-read";
+import { customTypeRename } from "./hooks/customType-rename";
+import { customTypeUpdate } from "./hooks/customType-update";
+import { sliceAssetDelete } from "./hooks/slice-asset-delete";
+import { sliceAssetRead } from "./hooks/slice-asset-read";
+import { sliceAssetUpdate } from "./hooks/slice-asset-update";
+import { sliceCreate } from "./hooks/slice-create";
+import { sliceDelete } from "./hooks/slice-delete";
+import { sliceLibraryRead } from "./hooks/sliceLibrary-read";
+import { sliceRead } from "./hooks/slice-read";
+import { sliceRename } from "./hooks/slice-rename";
 import { sliceSimulatorSetupRead } from "./hooks/sliceSimulator-setup-read";
+import { sliceUpdate } from "./hooks/slice-update";
+import { snippetRead } from "./hooks/snippet-read";
 
 export const plugin = defineSliceMachinePlugin<PluginOptions>({
 	meta: {
@@ -26,14 +34,22 @@ export const plugin = defineSliceMachinePlugin<PluginOptions>({
 	setup({ hook }) {
 		hook("slice:create", sliceCreate);
 		hook("slice:update", sliceUpdate);
+		hook("slice:rename", sliceRename);
 		hook("slice:delete", sliceDelete);
 		hook("slice:read", sliceRead);
+		hook("slice:asset:update", sliceAssetUpdate);
+		hook("slice:asset:delete", sliceAssetDelete);
+		hook("slice:asset:read", sliceAssetRead);
 		hook("slice-library:read", sliceLibraryRead);
 
 		hook("custom-type:create", customTypeCreate);
 		hook("custom-type:update", customTypeUpdate);
+		hook("custom-type:rename", customTypeRename);
 		hook("custom-type:delete", customTypeDelete);
 		hook("custom-type:read", customTypeRead);
+		hook("custom-type:asset:update", customTypeAssetUpdate);
+		hook("custom-type:asset:delete", customTypeAssetDelete);
+		hook("custom-type:asset:read", customTypeAssetRead);
 		hook("custom-type-library:read", customTypeLibraryRead);
 
 		hook("snippet:read", snippetRead);