@uniformdev/cli 20.74.6-alpha.1 → 20.74.6-alpha.3

package/dist/{chunk-TPAFG3LW.mjs → chunk-IBJEWQVU.mjs}

@@ -388,6 +388,16 @@ function readFileToObject(filename) {
   const file = readFileSync(filename, "utf8");
   return load(file, { filename, json: true });
 }
+var ENTITY_ID_CHUNK_SIZE = 100;
+function* chunkEntityIds(ids, chunkSize = ENTITY_ID_CHUNK_SIZE) {
+  if (!ids) {
+    yield void 0;
+    return;
+  }
+  for (let index = 0; index < ids.length; index += chunkSize) {
+    yield ids.slice(index, index + chunkSize);
+  }
+}
 async function* paginateAsync(fetchPage, options) {
   const pageSize = options.pageSize ?? 100;
   if (pageSize < 1) {
@@ -440,6 +450,21 @@ function getEntityBatchSize(entityType, config) {
   }
   return entityBatchSizeDefaults[entityType];
 }
+function getPublishScope(entityType, config) {
+  const publish = config.entitiesConfig?.[entityType]?.publish;
+  if (!publish) {
+    return void 0;
+  }
+  if (publish === true || publish === "all") {
+    return "all";
+  }
+  if (publish === "pushed") {
+    return "pushed";
+  }
+  throw new Error(
+    `Invalid publish option '${publish}' for ${entityType}. Expected true, false, 'all', or 'pushed'.`
+  );
+}
 function resolveEntityBatchSize({
   entityType,
   cliBatchSize,
@@ -549,9 +574,11 @@ export {
   isPathAPackageFile,
   emitWithFormat,
   readFileToObject,
+  chunkEntityIds,
   paginateAsync,
   isPaginatedSyncEntity,
   getEntityBatchSize,
+  getPublishScope,
   withBatchSizeOptions,
   applyDefaultSyncConfiguration,
   getEntityOption,

package/dist/defaultConfig.d.mts

@@ -1,4 +1,4 @@
-import { C as CLIConfiguration, E as EntityTypes } from './index-DeoTNXj-.mjs';
+import { C as CLIConfiguration, E as EntityTypes } from './index-CxaxRfj3.mjs';
 
 type UniformConfigAllOptions = {
     /**

package/dist/defaultConfig.mjs

@@ -1,4 +1,4 @@
-import "./chunk-TPAFG3LW.mjs";
+import "./chunk-IBJEWQVU.mjs";
 
 // src/sync/allSerializableEntitiesConfig.ts
 var allSerializableEntitiesConfig = {
@@ -11,11 +11,11 @@ var allSerializableEntitiesConfig = {
   projectMapDefinition: {},
   projectMapNode: {},
   contentType: {},
-  composition: { publish: true },
-  entry: { publish: true },
-  entryPattern: { publish: true },
-  componentPattern: { publish: true },
-  compositionPattern: { publish: true },
+  composition: { publish: "all" },
+  entry: { publish: "all" },
+  entryPattern: { publish: "all" },
+  componentPattern: { publish: "all" },
+  compositionPattern: { publish: "all" },
   asset: {},
   workflow: {},
   webhook: {},

package/dist/{index-DeoTNXj-.d.mts → index-CxaxRfj3.d.mts}

@@ -13,8 +13,17 @@ type EntityConfiguration = {
     disabled?: true;
 };
 type EntityWithStateConfiguration = EntityConfiguration & Partial<StateArgs>;
+/**
+ * What a push should publish once it has written its entities to preview.
+ *
+ * - `all`: publish every entity of this type in the project that has unpublished changes, whether or
+ *   not it came from the push source. This is what `publish: true` has always done.
+ * - `pushed`: publish only the entities present in the push source (directory or package file).
+ */
+type PublishScope = 'all' | 'pushed';
 type PublishableEntitiesConfiguration = EntityWithStateConfiguration & {
-    publish?: boolean;
+    /** `true` is an alias for `'all'`, kept for backwards compatibility. */
+    publish?: boolean | PublishScope;
     batchSize?: number;
 };
 type SerializationEntitiesConfiguration = Record<EntityTypes, {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { C as CLIConfiguration } from './index-DeoTNXj-.mjs';
+export { C as CLIConfiguration } from './index-CxaxRfj3.mjs';

package/dist/index.mjs

@@ -3,10 +3,12 @@ import {
   CLI_USER_AGENT,
   __require,
   applyDefaultSyncConfiguration,
+  chunkEntityIds,
   emitWithFormat,
   getDirectoryOrFilename,
   getEntityBatchSize,
   getEntityOption,
+  getPublishScope,
   isPaginatedSyncEntity,
   isPathAPackageFile,
   nodeFetchProxy,
@@ -21,7 +23,7 @@ import {
   withFormatOptions,
   withProjectOptions,
   withTeamOptions
-} from "./chunk-TPAFG3LW.mjs";
+} from "./chunk-IBJEWQVU.mjs";
 
 // src/index.ts
 import * as dotenv from "dotenv";
@@ -875,6 +877,7 @@ async function syncEngine({
           throw new SyncEngineError(e, sourceObject2);
         }
       } finally {
+        syncEngineEvents.emit("objectWritten", { id: ids[0], action: "update" });
         log2({
           action: "update",
           id: ids[0],
@@ -910,6 +913,7 @@ async function syncEngine({
             throw new SyncEngineError(e, sourceObject2);
           }
         } finally {
+          syncEngineEvents.emit("objectWritten", { id, action: "create" });
           log2({
             action: "create",
             id,
@@ -4208,16 +4212,28 @@ var selectIdentifier3 = (response) => {
   }
   return baseId;
 };
-function parseCompositionSerializedId(providerId) {
-  const [compositionId, editionId] = providerId.split(" (");
-  return { compositionId, editionId: editionId?.slice(0, -1) };
-}
 var selectDisplayName3 = (component) => {
   const name = component.composition._name ?? component.composition._slug ?? component.composition._id;
   const edition = component.editionId ? component.editionName ?? component.editionId : void 0;
   return `${name} (pid: ${component.composition._id}${edition ? `, edition: ${edition}` : ""})`;
 };
 
+// src/commands/canvas/util/serializedIds.ts
+function parseSerializedId(serializedId) {
+  const [id, editionId] = serializedId.split(" (");
+  return { id, editionId: editionId?.slice(0, -1) };
+}
+function splitSerializedIds(ids) {
+  return ids.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function toRawEntityIds(serializedIds) {
+  const rawIds = serializedIds.map((serializedId) => {
+    const { id, editionId } = parseSerializedId(serializedId);
+    return editionId ?? id;
+  });
+  return Array.from(new Set(rawIds));
+}
+
 // src/commands/canvas/componentInstanceEngineDataSource.ts
 function createComponentInstanceEngineDataSource({
   client,
@@ -4227,39 +4243,44 @@ function createComponentInstanceEngineDataSource({
   patternType,
   verbose,
   batchSize,
+  editions = "all",
   ...clientOptions
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    const componentInstances = paginateAsync(
-      async (offset, limit2) => {
-        const parameters = {
-          ...clientOptions,
-          limit: limit2,
-          offset,
-          pattern: onlyCompositions ? false : onlyPatterns ? true : void 0,
-          state: stateId,
-          skipPatternResolution: true,
-          skipOverridesResolution: true,
-          withComponentIDs: true,
-          patternType,
-          editions: "all"
+    const pageSize = batchSize ?? 100;
+    for (const compositionIDsChunk of chunkEntityIds(clientOptions.compositionIDs)) {
+      const componentInstances = paginateAsync(
+        async (offset, limit2) => {
+          const parameters = {
+            ...clientOptions,
+            compositionIDs: compositionIDsChunk,
+            limit: limit2,
+            offset,
+            pattern: onlyCompositions ? false : onlyPatterns ? true : void 0,
+            state: stateId,
+            skipPatternResolution: true,
+            skipOverridesResolution: true,
+            withComponentIDs: true,
+            patternType,
+            editions
+          };
+          if (verbose) {
+            console.log(`\u{1F41B} pull compositions: `, parameters);
+          }
+          return (await client.getCompositionList(parameters)).compositions;
+        },
+        { pageSize, verbose, entityName: "compositions" }
+      );
+      for await (const compositionListItem of componentInstances) {
+        const result = {
+          id: selectIdentifier3(compositionListItem),
+          displayName: selectDisplayName3(compositionListItem),
+          providerId: selectIdentifier3(compositionListItem),
+          object: prepCompositionForDisk(compositionListItem)
         };
-        if (verbose) {
-          console.log(`\u{1F41B} pull compositions: `, parameters);
-        }
-        return (await client.getCompositionList(parameters)).compositions;
-      },
-      { pageSize: batchSize ?? 100, verbose, entityName: "compositions" }
-    );
-    for await (const compositionListItem of componentInstances) {
-      const result = {
-        id: selectIdentifier3(compositionListItem),
-        displayName: selectDisplayName3(compositionListItem),
-        providerId: selectIdentifier3(compositionListItem),
-        object: prepCompositionForDisk(compositionListItem)
-      };
-      yield result;
+        yield result;
+      }
     }
   }
   return {
@@ -4267,9 +4288,10 @@ function createComponentInstanceEngineDataSource({
     objects: getObjects(),
     deleteObject: async (providerId) => {
       if (verbose) {
-        console.log(`\u{1F41B} delete composition: (id: ${parseCompositionSerializedId(providerId)})`);
+        console.log(`\u{1F41B} delete composition: (id: ${providerId})`);
       }
-      await client.removeComposition(parseCompositionSerializedId(providerId));
+      const { id: compositionId, editionId } = parseSerializedId(providerId);
+      await client.removeComposition({ compositionId, editionId });
     },
     writeObject: async (object4) => {
       if (verbose) {
@@ -4334,29 +4356,23 @@ var CompositionPublishModule = {
       console.error(`Specify --all or composition ID(s) to publish.`);
       process.exit(1);
     }
-    const compositionIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const compositionIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getCanvasClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const source = createComponentInstanceEngineDataSource({
+    const createDataSource = (state) => createComponentInstanceEngineDataSource({
       client,
-      state: "preview",
-      compositionIDs: compositionIDsArray,
-      onlyCompositions,
-      onlyPatterns,
-      patternType,
-      verbose,
-      batchSize: resolvedBatchSize
-    });
-    const target = createComponentInstanceEngineDataSource({
-      client,
-      state: "published",
-      compositionIDs: compositionIDsArray,
+      state,
+      compositionIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: compositionIDs ? "raw" : "all",
       onlyCompositions,
       onlyPatterns,
       patternType,
       verbose,
       batchSize: resolvedBatchSize
     });
+    const source = createDataSource("preview");
+    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -4960,8 +4976,9 @@ var CompositionUnpublishModule = {
         console.log(`Composition ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
+        const { id: compositionId, editionId } = parseSerializedId(id);
         actions.push(
-          client.removeComposition({ ...parseCompositionSerializedId(id), state: CANVAS_PUBLISHED_STATE2 }).catch((err) => {
+          client.removeComposition({ compositionId, editionId, state: CANVAS_PUBLISHED_STATE2 }).catch((err) => {
             const isNotFound = err instanceof ApiClientError && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -6262,10 +6279,6 @@ var selectEntryIdentifier = (e) => {
   }
   return baseId;
 };
-function parseEntrySerializedId(providerId) {
-  const [entryId, editionId] = providerId.split(" (");
-  return { entryId, editionId: editionId?.slice(0, -1) };
-}
 var selectEntryDisplayName = (e) => {
   const name = e.entry._name ?? "Untitled";
   const edition = e.editionId ? e.editionName ?? e.editionId : void 0;
@@ -6280,49 +6293,54 @@ function createEntryEngineDataSource({
   onlyPatterns,
   entryIDs,
   batchSize,
-  verbose
+  verbose,
+  editions = "all"
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    const entries = paginateAsync(
-      async (offset, limit2) => {
-        try {
-          return (await client.getEntries({
-            offset,
-            limit: limit2,
-            entryIDs,
-            pattern: onlyEntries ? false : onlyPatterns ? true : void 0,
-            skipDataResolution: true,
-            skipOverridesResolution: true,
-            skipPatternResolution: true,
-            state: stateId,
-            withComponentIDs: true,
-            editions: "all"
-          })).entries;
-        } catch (error) {
-          if (error instanceof ApiClientError2 && error.errorMessage === "Entry not found or not published") {
-            return [];
+    const pageSize = batchSize ?? 100;
+    for (const entryIDsChunk of chunkEntityIds(entryIDs)) {
+      const entries = paginateAsync(
+        async (offset, limit2) => {
+          try {
+            return (await client.getEntries({
+              offset,
+              limit: limit2,
+              entryIDs: entryIDsChunk,
+              pattern: onlyEntries ? false : onlyPatterns ? true : void 0,
+              skipDataResolution: true,
+              skipOverridesResolution: true,
+              skipPatternResolution: true,
+              state: stateId,
+              withComponentIDs: true,
+              editions
+            })).entries;
+          } catch (error) {
+            if (error instanceof ApiClientError2 && error.errorMessage === "Entry not found or not published") {
+              return [];
+            }
+            throw error;
           }
-          throw error;
-        }
-      },
-      { pageSize: batchSize ?? 100, verbose, entityName: "entries" }
-    );
-    for await (const e of entries) {
-      const result = {
-        id: selectEntryIdentifier(e),
-        displayName: selectEntryDisplayName(e),
-        providerId: selectEntryIdentifier(e),
-        object: prepCompositionForDisk(e)
-      };
-      yield result;
+        },
+        { pageSize, verbose, entityName: "entries" }
+      );
+      for await (const e of entries) {
+        const result = {
+          id: selectEntryIdentifier(e),
+          displayName: selectEntryDisplayName(e),
+          providerId: selectEntryIdentifier(e),
+          object: prepCompositionForDisk(e)
+        };
+        yield result;
+      }
     }
   }
   return {
     name: "Uniform API",
     objects: getObjects(),
     deleteObject: async (providerId) => {
-      await client.deleteEntry(parseEntrySerializedId(providerId));
+      const { id: entryId, editionId } = parseSerializedId(providerId);
+      await client.deleteEntry({ entryId, editionId });
     },
     writeObject: async ({ object: object4 }) => {
       await client.upsertEntry({ ...convertEntryToPutEntry(object4), state: stateId });
@@ -6373,23 +6391,21 @@ var EntryPublishModule = {
       console.error(`Specify --all or entry ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
-    const source = createEntryEngineDataSource({
-      client,
-      state: "preview",
-      entryIDs: entryIDsArray,
-      onlyEntries: true,
-      batchSize: resolvedBatchSize
-    });
-    const target = createEntryEngineDataSource({
+    const createDataSource = (state) => createEntryEngineDataSource({
       client,
-      state: "published",
-      entryIDs: entryIDsArray,
+      state,
+      entryIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: entryIDs ? "raw" : "all",
       onlyEntries: true,
+      verbose,
       batchSize: resolvedBatchSize
     });
+    const source = createDataSource("preview");
+    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -6773,8 +6789,9 @@ var EntryUnpublishModule = {
         console.log(`Entry ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
+        const { id: entryId, editionId } = parseSerializedId(id);
         actions.push(
-          client.deleteEntry({ ...parseEntrySerializedId(id), state: CANVAS_PUBLISHED_STATE3 }).catch((err) => {
+          client.deleteEntry({ entryId, editionId, state: CANVAS_PUBLISHED_STATE3 }).catch((err) => {
             const isNotFound = err instanceof ApiClientError3 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -7003,23 +7020,21 @@ var EntryPatternPublishModule = {
       console.error(`Specify --all or entry pattern ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getContentClient({ apiKey, apiHost, edgeApiHost, fetch: fetch2, projectId });
-    const source = createEntryEngineDataSource({
+    const createDataSource = (state) => createEntryEngineDataSource({
       client,
-      state: "preview",
-      entryIDs: entryIDsArray,
-      onlyPatterns: true,
-      batchSize: resolvedBatchSize
-    });
-    const target = createEntryEngineDataSource({
-      client,
-      state: "published",
-      entryIDs: entryIDsArray,
+      state,
+      entryIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: entryIDs ? "raw" : "all",
       onlyPatterns: true,
+      verbose,
       batchSize: resolvedBatchSize
     });
+    const source = createDataSource("preview");
+    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -7377,8 +7392,9 @@ var EntryPatternUnpublishModule = {
         console.log(`Entry pattern ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
+        const { id: entryId, editionId } = parseSerializedId(id);
         actions.push(
-          client.deleteEntry({ ...parseEntrySerializedId(id), state: CANVAS_PUBLISHED_STATE4 }).catch((err) => {
+          client.deleteEntry({ entryId, editionId, state: CANVAS_PUBLISHED_STATE4 }).catch((err) => {
             const isNotFound = err instanceof ApiClientError4 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -13181,7 +13197,7 @@ var WebhookPullModule = {
 // src/commands/sync/commands/util.ts
 import ora2 from "ora";
 async function spinPromise(action, options) {
-  const { successText, failText } = typeof options === "object" ? options : { successText: void 0, failText: void 0 };
+  const { failText } = options;
   const spinner = ora2(options).start();
   const consoleReplay = [];
   const revertLog = patchConsole({
@@ -13219,6 +13235,7 @@ async function spinPromise(action, options) {
   process.on("SIGINT", executeReplayOnSigint);
   try {
     const result = await action;
+    const successText = typeof options.successText === "function" ? options.successText(result) : options.successText;
     const finalStatusText = spinner.text.startsWith(options.text) && spinner.text.length > options.text.length ? spinner.text.slice(options.text.length).trim() : `\u2699\uFE0F compared: ${numPad(0)} changes: 0`;
     const padding = " ".repeat(Math.max(4, 40 - successText.length));
     spinner.succeed(successText + padding + finalStatusText);
@@ -13500,160 +13517,112 @@ var SyncPushModule = {
         "No entities were configured to be pushed. Please make sure you have configuration file and at least one entity type is enabled."
       );
     }
-    for (const [entityType, module] of enabledEntities) {
+    const publishScopes = /* @__PURE__ */ new Map();
+    for (const { entityType } of publishableEntities) {
       try {
-        await spinPromise(
-          module.handler({
-            ...otherParams,
-            state: 0,
-            format: getFormat2(entityType, config2),
-            onlyCompositions: entityType === "composition" ? true : void 0,
-            onlyPatterns: ["pattern", "componentPattern", "compositionPattern"].includes(entityType) ? true : void 0,
-            patternType: entityType === "compositionPattern" ? "composition" : entityType === "componentPattern" ? "component" : void 0,
-            mode: getPushMode(entityType, config2),
-            directory: getPushFilename(entityType, config2),
-            allowEmptySource: config2.allowEmptySource,
-            ...isPaginatedSyncEntity(entityType) ? { resolvedBatchSize: getEntityBatchSize(entityType, config2) } : {}
-          }),
-          {
-            text: `${entityType}...`,
-            successText: entityType,
-            failText(error) {
-              return `${entityType}
-
- ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
+        publishScopes.set(entityType, getPublishScope(entityType, config2));
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
         process.exit(1);
       }
     }
-    if (config2.entitiesConfig?.componentPattern && config2.entitiesConfig?.componentPattern?.push?.disabled !== true && config2.entitiesConfig?.componentPattern?.publish) {
-      try {
-        await spinPromise(
-          ComponentPatternPublishModule.handler({
-            ...otherParams,
-            serialization: config2,
-            patternType: "component",
-            onlyPatterns: true,
-            all: true,
-            directory: getPushFilename("componentPattern", config2),
-            resolvedBatchSize: getEntityBatchSize("componentPattern", config2)
-          }),
-          {
-            text: "publishing component patterns...",
-            successText: "published component patterns",
-            failText(error) {
-              return `publishing component patterns
-
- ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
-      }
+    const pushedIds = /* @__PURE__ */ new Map();
+    for (const [entityType, module] of enabledEntities) {
+      const written = [];
+      const recordWrite = ({ id }) => written.push(id);
+      syncEngineEvents.on("objectWritten", recordWrite);
+      pushedIds.set(entityType, written);
+      await runStep({
+        text: `${entityType}...`,
+        successText: entityType,
+        failLabel: entityType,
+        run: () => module.handler({
+          ...otherParams,
+          state: 0,
+          format: getFormat2(entityType, config2),
+          ...getEntityDiscriminators(entityType),
+          mode: getPushMode(entityType, config2),
+          directory: getPushFilename(entityType, config2),
+          allowEmptySource: config2.allowEmptySource,
+          ...isPaginatedSyncEntity(entityType) ? { resolvedBatchSize: getEntityBatchSize(entityType, config2) } : {}
+        })
+      });
+      syncEngineEvents.off("objectWritten", recordWrite);
     }
-    if (config2.entitiesConfig?.compositionPattern && config2.entitiesConfig?.compositionPattern?.push?.disabled !== true && config2.entitiesConfig?.compositionPattern?.publish) {
-      try {
-        await spinPromise(
-          CompositionPatternPublishModule.handler({
-            ...otherParams,
-            serialization: config2,
-            all: true,
-            onlyPatterns: true,
-            patternType: "composition",
-            directory: getPushFilename("compositionPattern", config2),
-            resolvedBatchSize: getEntityBatchSize("compositionPattern", config2)
-          }),
-          {
-            text: "publishing composition patterns...",
-            successText: "published composition patterns",
-            failText(error) {
-              return `publishing composition patterns
-
- ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
+    for (const { entityType, module, label } of publishableEntities) {
+      const entityConfig = config2.entitiesConfig?.[entityType];
+      const scope = publishScopes.get(entityType);
+      if (entityConfig?.disabled === true || entityConfig?.push?.disabled === true || !scope) {
+        continue;
       }
-    }
-    if (config2.entitiesConfig?.composition && config2.entitiesConfig?.composition?.push?.disabled !== true && config2.entitiesConfig?.composition?.publish) {
-      try {
-        await spinPromise(
-          CompositionPublishModule.handler({
-            ...otherParams,
-            serialization: config2,
-            all: true,
-            onlyCompositions: true,
-            directory: getPushFilename("composition", config2),
-            resolvedBatchSize: getEntityBatchSize("composition", config2)
-          }),
-          {
-            text: "publishing compositions...",
-            successText: "published compositions",
-            failText(error) {
-              return `publishing compositions
-
- ${error.stack ?? error.message}`;
+      const directory = getPushFilename(entityType, config2);
+      await runStep({
+        text: `publishing ${label}...`,
+        // a push that changed nothing is not an error, but it must not read as "published" either
+        successText: (outcome) => outcome.skippedReason ? `skipped ${label}: ${outcome.skippedReason}` : `published ${label}`,
+        failLabel: `publishing ${label}`,
+        run: async () => {
+          let ids;
+          if (scope === "pushed") {
+            const written = pushedIds.get(entityType) ?? [];
+            if (written.length === 0) {
+              return { skippedReason: "nothing was pushed" };
             }
+            ids = written.join(",");
           }
-        );
-      } catch {
-        process.exit(1);
-      }
-    }
-    if (config2.entitiesConfig?.entry && config2.entitiesConfig?.entry?.push?.disabled !== true && config2.entitiesConfig?.entry?.publish) {
-      try {
-        await spinPromise(
-          EntryPublishModule.handler({
+          await module.handler({
             ...otherParams,
             serialization: config2,
-            all: true,
-            directory: getPushFilename("entry", config2),
-            resolvedBatchSize: getEntityBatchSize("entry", config2)
-          }),
-          {
-            text: "publishing entries...",
-            successText: "published entries",
-            failText(error) {
-              return `publishing entries
-
- ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
-      }
+            all: scope === "all",
+            ids,
+            ...getEntityDiscriminators(entityType),
+            directory,
+            resolvedBatchSize: getEntityBatchSize(entityType, config2)
+          });
+          return {};
+        }
+      });
     }
-    if (config2.entitiesConfig?.entryPattern && config2.entitiesConfig?.entryPattern?.push?.disabled !== true && config2.entitiesConfig?.entryPattern?.publish) {
-      try {
-        await spinPromise(
-          EntryPatternPublishModule.handler({
-            ...otherParams,
-            serialization: config2,
-            all: true,
-            directory: getPushFilename("entryPattern", config2),
-            resolvedBatchSize: getEntityBatchSize("entryPattern", config2)
-          }),
-          {
-            text: "publishing entry patterns...",
-            successText: "published entry patterns",
-            failText(error) {
-              return `publishing entry patterns
+  }
+};
+var publishableEntities = [
+  {
+    entityType: "componentPattern",
+    module: ComponentPatternPublishModule,
+    label: "component patterns"
+  },
+  {
+    entityType: "compositionPattern",
+    module: CompositionPatternPublishModule,
+    label: "composition patterns"
+  },
+  { entityType: "composition", module: CompositionPublishModule, label: "compositions" },
+  { entityType: "entry", module: EntryPublishModule, label: "entries" },
+  { entityType: "entryPattern", module: EntryPatternPublishModule, label: "entry patterns" }
+];
+var getEntityDiscriminators = (entityType) => ({
+  onlyCompositions: entityType === "composition" ? true : void 0,
+  onlyPatterns: ["pattern", "componentPattern", "compositionPattern"].includes(entityType) ? true : void 0,
+  patternType: entityType === "compositionPattern" ? "composition" : entityType === "componentPattern" ? "component" : void 0
+});
+var runStep = async ({
+  text,
+  successText,
+  failLabel,
+  run
+}) => {
+  try {
+    await spinPromise(run(), {
+      text,
+      successText,
+      failText(error) {
+        return `${failLabel}
 
  ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
       }
-    }
+    });
+  } catch {
+    process.exit(1);
   }
 };
 var getPushMode = (entityType, config2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/cli",
-  "version": "20.74.6-alpha.1+4cdd3b417d",
+  "version": "20.74.6-alpha.3+ac26410bba",
   "description": "Uniform command line interface tool",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./cli.js",
@@ -27,13 +27,13 @@
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
     "@thi.ng/mime": "^2.2.23",
-    "@uniformdev/assets": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/canvas": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/context": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/files": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/project-map": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/redirect": "20.74.6-alpha.1+4cdd3b417d",
-    "@uniformdev/richtext": "20.74.6-alpha.1+4cdd3b417d",
+    "@uniformdev/assets": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/canvas": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/context": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/files": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/project-map": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/redirect": "20.74.6-alpha.3+ac26410bba",
+    "@uniformdev/richtext": "20.74.6-alpha.3+ac26410bba",
     "call-bind": "^1.0.2",
     "colorette": "2.0.20",
     "cosmiconfig": "9.0.2",
@@ -79,5 +79,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4cdd3b417d4e8dbedf060014c9a3eb88ee44a4d4"
+  "gitHead": "ac26410bba86c828620eb1876847bbaffd639036"
 }