@uniformdev/cli 20.56.1-alpha.5 → 20.57.1

package/dist/index.mjs

@@ -1107,7 +1107,7 @@ import { PostHog } from "posthog-node";
 // package.json
 var package_default = {
   name: "@uniformdev/cli",
-  version: "20.56.0",
+  version: "20.57.1",
   description: "Uniform command line interface tool",
   license: "SEE LICENSE IN LICENSE.txt",
   main: "./cli.js",
@@ -1128,7 +1128,7 @@ var package_default = {
     build: "tsc --noEmit && tsup",
     dev: "tsup --watch",
     clean: "rimraf dist",
-    test: "jest --maxWorkers=1 --passWithNoTests",
+    test: "vitest run",
     lint: 'eslint "src/**/*.{js,ts,tsx}"',
     format: 'prettier --write "src/**/*.{js,ts,tsx}"'
   },
@@ -3795,7 +3795,156 @@ var ComponentModule = {
 // src/commands/canvas/commands/componentPattern.ts
 import yargs7 from "yargs";
 
+// src/commands/canvas/util/entityTypeValidation.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE2 } from "@uniformdev/canvas";
+function getCompositionActualType(composition) {
+  return composition.pattern ? composition.patternType === "component" ? "component-pattern" : "composition-pattern" : "composition";
+}
+function getEntryActualType(entry) {
+  return entry.pattern ? "entry-pattern" : "entry";
+}
+async function validateCompositionType(client, id, expectedType) {
+  try {
+    const composition = await client.getCompositionById({
+      compositionId: id,
+      skipDataResolution: true,
+      state: CANVAS_DRAFT_STATE2,
+      withPatternType: true
+    });
+    const actualType = getCompositionActualType(composition);
+    return {
+      actualType,
+      isValid: actualType === expectedType,
+      exists: true
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error && error.statusCode === 404) {
+      return {
+        actualType: expectedType,
+        isValid: false,
+        exists: false
+      };
+    }
+    throw error;
+  }
+}
+async function validateEntryType(client, id, expectedType) {
+  const res = await client.getEntries({
+    offset: 0,
+    limit: 1,
+    entryIDs: [id],
+    skipDataResolution: true,
+    state: CANVAS_DRAFT_STATE2,
+    pattern: expectedType === "entry-pattern" ? true : void 0
+  });
+  if (res.entries.length !== 1) {
+    return {
+      actualType: expectedType,
+      isValid: false,
+      exists: false
+    };
+  }
+  const entry = res.entries[0];
+  const actualType = getEntryActualType(entry);
+  return {
+    actualType,
+    isValid: actualType === expectedType,
+    exists: true
+  };
+}
+function getCompositionDisplayNameWithArticle(type) {
+  switch (type) {
+    case "composition":
+      return "a composition";
+    case "composition-pattern":
+      return "a composition pattern";
+    case "component-pattern":
+      return "a component pattern";
+  }
+}
+function getEntryDisplayNameWithArticle(type) {
+  return type === "entry" ? "an entry" : "an entry pattern";
+}
+function getCompositionDisplayName(type) {
+  switch (type) {
+    case "composition":
+      return "Composition";
+    case "composition-pattern":
+      return "Composition Pattern";
+    case "component-pattern":
+      return "Component Pattern";
+  }
+}
+function getEntryDisplayName(type) {
+  return type === "entry" ? "Entry" : "Entry Pattern";
+}
+function getCommandVerb(action) {
+  return action === "delete" ? "remove" : action;
+}
+function formatCompositionTypeError(id, actualType, expectedType, action) {
+  const actualDisplayName = getCompositionDisplayNameWithArticle(actualType);
+  const expectedDisplayName = getCompositionDisplayNameWithArticle(expectedType);
+  return `Error: The provided ID belongs to ${actualDisplayName}, not ${expectedDisplayName}.
+To ${action} ${actualDisplayName}, use: uniform canvas ${actualType} ${getCommandVerb(action)} ${id}`;
+}
+function formatEntryTypeError(id, actualType, expectedType, action) {
+  const actualDisplayName = getEntryDisplayNameWithArticle(actualType);
+  const expectedDisplayName = getEntryDisplayNameWithArticle(expectedType);
+  return `Error: The provided ID belongs to ${actualDisplayName}, not ${expectedDisplayName}.
+To ${action} ${actualDisplayName}, use: uniform canvas ${actualType} ${getCommandVerb(action)} ${id}`;
+}
+
 // src/commands/canvas/commands/composition/get.ts
+function createCompositionGetHandler(expectedType) {
+  return async ({
+    apiHost,
+    edgeApiHost,
+    apiKey,
+    proxy,
+    id,
+    format,
+    filename,
+    state,
+    project: projectId,
+    resolvePatterns,
+    resolveOverrides,
+    componentIDs,
+    resolveData,
+    diagnostics,
+    resolutionDepth,
+    verbose
+  }) => {
+    const parameters = {
+      compositionId: id,
+      state: convertStateOption(state),
+      skipPatternResolution: !resolvePatterns,
+      skipOverridesResolution: !resolveOverrides,
+      withComponentIDs: componentIDs,
+      skipDataResolution: !resolveData,
+      diagnostics: resolveData ? diagnostics : void 0,
+      resolutionDepth: resolveData ? resolutionDepth : void 0,
+      withPatternType: true
+    };
+    if (verbose) {
+      console.log(`\u{1F41B} get ${expectedType}:`, parameters);
+    }
+    const fetch2 = nodeFetchProxy(proxy, verbose);
+    const client = getCanvasClient({ apiKey, edgeApiHost, apiHost, fetch: fetch2, projectId });
+    const composition = await client.getCompositionById(parameters);
+    const actualType = getCompositionActualType(composition);
+    if (actualType !== expectedType) {
+      console.error(formatCompositionTypeError(id, actualType, expectedType, "get"));
+      process.exit(1);
+    }
+    const {
+      // We fetch pattern type for type validation, but historically we did not include it in the payload so excluding for now
+      patternType,
+      ...rest
+    } = composition;
+    const res = prepCompositionForDisk(rest);
+    emitWithFormat(res, format, filename);
+  };
+}
 var CompositionGetModule = {
   command: "get <id>",
   describe: "Fetch a composition",
@@ -3807,7 +3956,7 @@ var CompositionGetModule = {
             withDebugOptions(
               yargs43.positional("id", {
                 demandOption: true,
-                describe: "Composition/pattern public ID to fetch"
+                describe: "Composition public ID to fetch"
               }).option({
                 resolvePatterns: {
                   type: "boolean",
@@ -3846,48 +3995,14 @@ var CompositionGetModule = {
       )
     )
   ),
-  handler: async ({
-    apiHost,
-    edgeApiHost,
-    apiKey,
-    proxy,
-    id,
-    format,
-    filename,
-    state,
-    project: projectId,
-    resolvePatterns,
-    resolveOverrides,
-    componentIDs,
-    resolveData,
-    diagnostics,
-    resolutionDepth,
-    verbose
-  }) => {
-    const parameters = {
-      compositionId: id,
-      state: convertStateOption(state),
-      skipPatternResolution: !resolvePatterns,
-      skipOverridesResolution: !resolveOverrides,
-      withComponentIDs: componentIDs,
-      skipDataResolution: !resolveData,
-      diagnostics: resolveData ? diagnostics : void 0,
-      resolutionDepth: resolveData ? resolutionDepth : void 0
-    };
-    if (verbose) {
-      console.log(`\u{1F41B} get composition:`, parameters);
-    }
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getCanvasClient({ apiKey, edgeApiHost, apiHost, fetch: fetch2, projectId });
-    const res = prepCompositionForDisk(await client.getCompositionById(parameters));
-    emitWithFormat(res, format, filename);
-  }
+  handler: createCompositionGetHandler("composition")
 };
 
 // src/commands/canvas/commands/componentPattern/get.ts
 var ComponentPatternGetModule = {
   ...CompositionGetModule,
-  describe: "Fetch a component pattern"
+  describe: "Fetch a component pattern",
+  handler: createCompositionGetHandler("component-pattern")
 };
 
 // src/commands/canvas/commands/composition/list.ts
@@ -4611,6 +4726,37 @@ var ComponentPatternPushModule = {
 };
 
 // src/commands/canvas/commands/composition/remove.ts
+function createCompositionRemoveHandler(expectedType) {
+  return async ({
+    apiHost,
+    apiKey,
+    proxy,
+    id,
+    project: projectId,
+    verbose,
+    whatIf
+  }) => {
+    if (verbose) {
+      console.log(`\u{1F41B} remove ${expectedType}: (id: ${id})`);
+    }
+    const fetch2 = nodeFetchProxy(proxy, verbose);
+    const client = getCanvasClient({ apiKey, apiHost, fetch: fetch2, projectId });
+    const validation = await validateCompositionType(client, id, expectedType);
+    if (!validation.exists) {
+      console.error(`Error: ${getCompositionDisplayName(expectedType)} with ID "${id}" not found.`);
+      process.exit(1);
+    }
+    if (!validation.isValid) {
+      console.error(formatCompositionTypeError(id, validation.actualType, expectedType, "delete"));
+      process.exit(1);
+    }
+    if (!whatIf) {
+      await client.removeComposition({ compositionId: id });
+    } else {
+      whatIfSimpleLog({ id, displayName: getCompositionDisplayName(expectedType), action: "delete" });
+    }
+  };
+}
 var CompositionRemoveModule = {
   command: "remove <id>",
   aliases: ["delete", "rm"],
@@ -4621,30 +4767,21 @@ var CompositionRemoveModule = {
         withProjectOptions(
           yargs43.positional("id", {
             demandOption: true,
-            describe: "Composition/pattern public ID to delete"
+            describe: "Composition public ID to delete"
           })
         )
       )
     )
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ),
-  handler: async ({ apiHost, apiKey, proxy, id, project: projectId, verbose, whatIf }) => {
-    if (verbose) {
-      console.log(`\u{1F41B} remove composition: (id: ${id})`);
-    }
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getCanvasClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    if (!whatIf) {
-      await client.removeComposition({ compositionId: id });
-    } else {
-      whatIfSimpleLog({ id, displayName: `Composition`, action: "delete" });
-    }
-  }
+  handler: createCompositionRemoveHandler("composition")
 };
 
 // src/commands/canvas/commands/componentPattern/remove.ts
 var ComponentPatternRemoveModule = {
   ...CompositionRemoveModule,
-  describe: "Delete a component pattern"
+  describe: "Delete a component pattern",
+  handler: createCompositionRemoveHandler("component-pattern")
 };
 
 // src/commands/canvas/commands/composition/unpublish.ts
@@ -4805,6 +4942,40 @@ var ComponentPatternUnpublishModule = {
 };
 
 // src/commands/canvas/commands/composition/update.ts
+function createCompositionUpdateHandler(expectedType) {
+  return async ({
+    apiHost,
+    apiKey,
+    proxy,
+    filename,
+    project: projectId,
+    state,
+    verbose,
+    whatIf
+  }) => {
+    if (verbose) {
+      console.log(`\u{1F41B} update ${expectedType}: (filename: ${filename}, state: ${convertStateOption(state)})`);
+    }
+    const fetch2 = nodeFetchProxy(proxy, verbose);
+    const client = getCanvasClient({ apiKey, apiHost, fetch: fetch2, projectId });
+    const file = readFileToObject(filename);
+    const id = file.composition._id;
+    const validation = await validateCompositionType(client, id, expectedType);
+    if (validation.exists && !validation.isValid) {
+      console.error(formatCompositionTypeError(id, validation.actualType, expectedType, "update"));
+      process.exit(1);
+    }
+    if (!whatIf) {
+      await client.updateComposition({ ...file, state: convertStateOption(state) });
+    } else {
+      whatIfSimpleLog({
+        id,
+        displayName: `${getCompositionDisplayName(expectedType)}: ${file.composition._name}`,
+        action: "update"
+      });
+    }
+  };
+}
 var CompositionUpdateModule = {
   command: "update <filename>",
   aliases: ["put"],
@@ -4823,29 +4994,14 @@ var CompositionUpdateModule = {
       )
     )
   ),
-  handler: async ({ apiHost, apiKey, proxy, filename, project: projectId, state, verbose, whatIf }) => {
-    if (verbose) {
-      console.log(`\u{1F41B} update composition: (filename: ${filename}, state: ${convertStateOption(state)})`);
-    }
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getCanvasClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const file = readFileToObject(filename);
-    if (!whatIf) {
-      await client.updateComposition({ ...file, state: convertStateOption(state) });
-    } else {
-      whatIfSimpleLog({
-        id: file.composition._id,
-        displayName: `Composition: ${file.composition._name}`,
-        action: "update"
-      });
-    }
-  }
+  handler: createCompositionUpdateHandler("composition")
 };
 
 // src/commands/canvas/commands/componentPattern/update.ts
 var ComponentPatternUpdateModule = {
   ...CompositionUpdateModule,
-  describe: "Insert or update a component pattern"
+  describe: "Insert or update a component pattern",
+  handler: createCompositionUpdateHandler("component-pattern")
 };
 
 // src/commands/canvas/commands/componentPattern.ts
@@ -4876,7 +5032,8 @@ import yargs9 from "yargs";
 // src/commands/canvas/commands/compositionPattern/get.ts
 var CompositionPatternGetModule = {
   ...CompositionGetModule,
-  describe: "Fetch a composition pattern"
+  describe: "Fetch a composition pattern",
+  handler: createCompositionGetHandler("composition-pattern")
 };
 
 // src/commands/canvas/commands/compositionPattern/list.ts
@@ -5059,7 +5216,8 @@ var CompositionPatternPushModule = {
 // src/commands/canvas/commands/compositionPattern/remove.ts
 var CompositionPatternRemoveModule = {
   ...CompositionRemoveModule,
-  describe: "Delete a composition pattern"
+  describe: "Delete a composition pattern",
+  handler: createCompositionRemoveHandler("composition-pattern")
 };
 
 // src/commands/canvas/commands/compositionPattern/unpublish.ts
@@ -5099,7 +5257,8 @@ var CompositionPatternUnpublishModule = {
 // src/commands/canvas/commands/compositionPattern/update.ts
 var CompositionPatternUpdateModule = {
   ...CompositionUpdateModule,
-  describe: "Insert or update a composition pattern"
+  describe: "Insert or update a composition pattern",
+  handler: createCompositionUpdateHandler("composition-pattern")
 };
 
 // src/commands/canvas/commands/compositionPattern.ts
@@ -5831,6 +5990,54 @@ var DataTypeModule = {
 import yargs13 from "yargs";
 
 // src/commands/canvas/commands/entry/get.ts
+function createEntryGetHandler(expectedType) {
+  return async ({
+    apiHost,
+    edgeApiHost,
+    apiKey,
+    proxy,
+    id,
+    format,
+    filename,
+    project: projectId,
+    state,
+    resolveData,
+    diagnostics,
+    resolutionDepth,
+    withComponentIDs,
+    verbose
+  }) => {
+    if (verbose) {
+      console.log(`\u{1F41B} get ${expectedType}: (id: ${id})`);
+    }
+    const fetch2 = nodeFetchProxy(proxy, verbose);
+    const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
+    const res = await client.getEntries({
+      offset: 0,
+      limit: 1,
+      entryIDs: [id],
+      state: convertStateOption(state),
+      skipOverridesResolution: true,
+      skipPatternResolution: true,
+      skipDataResolution: !resolveData,
+      diagnostics: resolveData ? diagnostics : void 0,
+      resolutionDepth: resolveData ? resolutionDepth : void 0,
+      withComponentIDs,
+      pattern: expectedType === "entry-pattern" ? true : void 0
+    });
+    if (res.entries.length !== 1) {
+      console.error(`Error: ${getEntryDisplayName(expectedType)} with ID "${id}" not found.`);
+      process.exit(1);
+    }
+    const entry = res.entries[0];
+    const actualType = getEntryActualType(entry);
+    if (actualType !== expectedType) {
+      console.error(formatEntryTypeError(id, actualType, expectedType, "get"));
+      process.exit(1);
+    }
+    emitWithFormat(entry, format, filename);
+  };
+}
 var EntryGetModule = {
   command: "get <id>",
   describe: "Get an entry",
@@ -5870,41 +6077,7 @@ var EntryGetModule = {
       )
     )
   ),
-  handler: async ({
-    apiHost,
-    edgeApiHost,
-    apiKey,
-    proxy,
-    id,
-    format,
-    filename,
-    project: projectId,
-    state,
-    resolveData,
-    diagnostics,
-    resolutionDepth,
-    withComponentIDs,
-    verbose
-  }) => {
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
-    const res = await client.getEntries({
-      offset: 0,
-      limit: 1,
-      entryIDs: [id],
-      state: convertStateOption(state),
-      skipOverridesResolution: true,
-      skipPatternResolution: true,
-      skipDataResolution: !resolveData,
-      diagnostics: resolveData ? diagnostics : void 0,
-      resolutionDepth: resolveData ? resolutionDepth : void 0,
-      withComponentIDs
-    });
-    if (res.entries.length !== 1) {
-      throw new Error(`Entry with ID ${id} not found`);
-    }
-    emitWithFormat(res.entries[0], format, filename);
-  }
+  handler: createEntryGetHandler("entry")
 };
 
 // src/commands/canvas/commands/entry/list.ts
@@ -6340,6 +6513,37 @@ var EntryPushModule = {
 };
 
 // src/commands/canvas/commands/entry/remove.ts
+function createEntryRemoveHandler(expectedType) {
+  return async ({
+    apiHost,
+    apiKey,
+    proxy,
+    id,
+    project: projectId,
+    verbose,
+    whatIf
+  }) => {
+    if (verbose) {
+      console.log(`\u{1F41B} remove ${expectedType}: (id: ${id})`);
+    }
+    const fetch2 = nodeFetchProxy(proxy, verbose);
+    const client = getContentClient({ apiKey, apiHost, fetch: fetch2, projectId });
+    const validation = await validateEntryType(client, id, expectedType);
+    if (!validation.exists) {
+      console.error(`Error: ${getEntryDisplayName(expectedType)} with ID "${id}" not found.`);
+      process.exit(1);
+    }
+    if (!validation.isValid) {
+      console.error(formatEntryTypeError(id, validation.actualType, expectedType, "delete"));
+      process.exit(1);
+    }
+    if (!whatIf) {
+      await client.deleteEntry({ entryId: id });
+    } else {
+      whatIfSimpleLog({ id, displayName: getEntryDisplayName(expectedType), action: "delete" });
+    }
+  };
+}
 var EntryRemoveModule = {
   command: "remove <id>",
   aliases: ["delete", "rm"],
@@ -6353,15 +6557,7 @@ var EntryRemoveModule = {
       )
     )
   ),
-  handler: async ({ apiHost, apiKey, proxy, id, project: projectId, verbose, whatIf }) => {
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getContentClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    if (!whatIf) {
-      await client.deleteEntry({ entryId: id });
-    } else {
-      whatIfSimpleLog({ id, displayName: `Entry`, action: "delete" });
-    }
-  }
+  handler: createEntryRemoveHandler("entry")
 };
 
 // src/commands/canvas/commands/entry/unpublish.ts
@@ -6455,22 +6651,8 @@ var EntryUnpublishModule = {
 };
 
 // src/commands/canvas/commands/entry/update.ts
-var EntryUpdateModule = {
-  command: "update <filename>",
-  aliases: ["put"],
-  describe: "Insert or update an entry",
-  builder: (yargs43) => withConfiguration(
-    withDebugOptions(
-      withApiOptions(
-        withProjectOptions(
-          withStateOptions(
-            yargs43.positional("filename", { demandOption: true, describe: "Entry file to put" })
-          )
-        )
-      )
-    )
-  ),
-  handler: async ({
+function createEntryUpdateHandler(expectedType) {
+  return async ({
     apiHost,
     edgeApiHost,
     apiKey,
@@ -6481,15 +6663,45 @@ var EntryUpdateModule = {
     verbose,
     whatIf
   }) => {
+    if (verbose) {
+      console.log(`\u{1F41B} update ${expectedType}: (filename: ${filename}, state: ${convertStateOption(state)})`);
+    }
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
     const file = readFileToObject(filename);
+    const id = file.entry._id;
+    const validation = await validateEntryType(client, id, expectedType);
+    if (validation.exists && !validation.isValid) {
+      console.error(formatEntryTypeError(id, validation.actualType, expectedType, "update"));
+      process.exit(1);
+    }
     if (!whatIf) {
       await client.upsertEntry({ ...file, state: convertStateOption(state) });
     } else {
-      whatIfSimpleLog({ id: file.entry._id, displayName: `Entry: ${file.entry._name}`, action: "update" });
+      whatIfSimpleLog({
+        id,
+        displayName: `${getEntryDisplayName(expectedType)}: ${file.entry._name}`,
+        action: "update"
+      });
     }
-  }
+  };
+}
+var EntryUpdateModule = {
+  command: "update <filename>",
+  aliases: ["put"],
+  describe: "Insert or update an entry",
+  builder: (yargs43) => withConfiguration(
+    withDebugOptions(
+      withApiOptions(
+        withProjectOptions(
+          withStateOptions(
+            yargs43.positional("filename", { demandOption: true, describe: "Entry file to put" })
+          )
+        )
+      )
+    )
+  ),
+  handler: createEntryUpdateHandler("entry")
 };
 
 // src/commands/canvas/commands/entry.ts
@@ -6515,10 +6727,22 @@ var EntryPatternGetModule = {
         withApiOptions(
           withProjectOptions(
             withStateOptions(
-              yargs43.positional("id", {
-                demandOption: true,
-                describe: "Entry pattern public ID to fetch"
-              }).option({
+              yargs43.positional("id", { demandOption: true, describe: "Entry pattern public ID to fetch" }).option({
+                resolveData: {
+                  type: "boolean",
+                  default: false,
+                  describe: "Resolve all data resources used by the entry pattern"
+                },
+                diagnostics: {
+                  type: "boolean",
+                  default: false,
+                  describe: "Include diagnostics information when resolving data"
+                },
+                resolutionDepth: {
+                  type: "number",
+                  default: 1,
+                  describe: "Controls how many levels deep content references should be resolved"
+                },
                 withComponentIDs: {
                   type: "boolean",
                   default: false,
@@ -6532,36 +6756,7 @@ var EntryPatternGetModule = {
       )
     )
   ),
-  handler: async ({
-    apiHost,
-    apiKey,
-    proxy,
-    id,
-    format,
-    filename,
-    project: projectId,
-    state,
-    withComponentIDs,
-    verbose
-  }) => {
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getContentClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const res = await client.getEntries({
-      offset: 0,
-      limit: 1,
-      entryIDs: [id],
-      state: convertStateOption(state),
-      skipOverridesResolution: true,
-      skipPatternResolution: true,
-      skipDataResolution: true,
-      pattern: true,
-      withComponentIDs
-    });
-    if (res.entries.length !== 1) {
-      throw new Error(`Entry pattern with ID ${id} not found`);
-    }
-    emitWithFormat(res.entries[0], format, filename);
-  }
+  handler: createEntryGetHandler("entry-pattern")
 };
 
 // src/commands/canvas/commands/entryPattern/list.ts
@@ -6925,15 +7120,7 @@ var EntryPatternRemoveModule = {
       )
     )
   ),
-  handler: async ({ apiHost, apiKey, proxy, id, project: projectId, verbose, whatIf }) => {
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getContentClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    if (!whatIf) {
-      await client.deleteEntry({ entryId: id });
-    } else {
-      whatIfSimpleLog({ id, displayName: `Entry Pattern`, action: "delete" });
-    }
-  }
+  handler: createEntryRemoveHandler("entry-pattern")
 };
 
 // src/commands/canvas/commands/entryPattern/unpublish.ts
@@ -7042,30 +7229,7 @@ var EntryPatternUpdateModule = {
       )
     )
   ),
-  handler: async ({
-    apiHost,
-    edgeApiHost,
-    apiKey,
-    proxy,
-    filename,
-    project: projectId,
-    state,
-    verbose,
-    whatIf
-  }) => {
-    const fetch2 = nodeFetchProxy(proxy, verbose);
-    const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
-    const file = readFileToObject(filename);
-    if (!whatIf) {
-      await client.upsertEntry({ ...file, state: convertStateOption(state) });
-    } else {
-      whatIfSimpleLog({
-        id: file.entry._id,
-        displayName: `Entry Pattern: ${file.entry._name}`,
-        action: "update"
-      });
-    }
-  }
+  handler: createEntryUpdateHandler("entry-pattern")
 };
 
 // src/commands/canvas/commands/entryPattern.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/cli",
-  "version": "20.56.1-alpha.5+1bce2eca70",
+  "version": "20.57.1",
   "description": "Uniform command line interface tool",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./cli.js",
@@ -21,20 +21,20 @@
     "build": "tsc --noEmit && tsup",
     "dev": "tsup --watch",
     "clean": "rimraf dist",
-    "test": "jest --maxWorkers=1 --passWithNoTests",
+    "test": "vitest run",
     "lint": "eslint \"src/**/*.{js,ts,tsx}\"",
     "format": "prettier --write \"src/**/*.{js,ts,tsx}\""
   },
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",
     "@thi.ng/mime": "^2.2.23",
-    "@uniformdev/assets": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/canvas": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/context": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/files": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/project-map": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/redirect": "20.56.1-alpha.5+1bce2eca70",
-    "@uniformdev/richtext": "20.56.1-alpha.5+1bce2eca70",
+    "@uniformdev/assets": "20.57.1",
+    "@uniformdev/canvas": "20.57.1",
+    "@uniformdev/context": "20.57.1",
+    "@uniformdev/files": "20.57.1",
+    "@uniformdev/project-map": "20.57.1",
+    "@uniformdev/redirect": "20.57.1",
+    "@uniformdev/richtext": "20.57.1",
     "call-bind": "^1.0.2",
     "colorette": "2.0.20",
     "cosmiconfig": "9.0.0",
@@ -81,5 +81,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1bce2eca70191de304d93909e5cf08740b01fb5a"
+  "gitHead": "1e3550de803a5532c1facf22ce6513001c847650"
 }