@uniformdev/cli 20.57.2-alpha.22 → 20.57.2-alpha.24

package/dist/defaultConfig.d.mts

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

package/dist/{index-Cs_pXOjF.d.mts → index-B-KaB0aa.d.mts}

@@ -12,11 +12,17 @@ type EntityConfigurationBase = {
     format?: SyncFileFormat;
     disabled?: true;
 };
+type EntityFilterCriteriaConfig = {
+    type: 'ids';
+    match: string[];
+} | {
+    type: 'nameContains';
+    match: string;
+};
 type EntityFilterInclude = {
     /** If set, only entities matching the criteria will be synced. Cannot be combined with `exclude`. */
     include: {
-        ids?: string[];
-        namePattern?: string;
+        filters: EntityFilterCriteriaConfig;
     };
     exclude?: never;
 };
@@ -24,8 +30,7 @@ type EntityFilterExclude = {
     include?: never;
     /** If set, entities matching the criteria will be excluded from sync. Cannot be combined with `include`. */
     exclude: {
-        ids?: string[];
-        namePattern?: string;
+        filters: EntityFilterCriteriaConfig;
     };
 };
 type EntityFilterNone = {

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -560,68 +560,169 @@ async function createArraySyncEngineDataSource({
 
 // src/sync/entityFilter.ts
 function resolveEntityFilter(entityConfig, operation) {
+  if (entityConfig) {
+    validateEntityConfig(entityConfig, operation);
+  }
   const directional = entityConfig?.[operation];
   const resolvedInclude = directional?.include ?? entityConfig?.include;
   const resolvedExclude = directional?.exclude ?? entityConfig?.exclude;
-  const includeIds = resolvedInclude?.ids;
-  const excludeIds = resolvedExclude?.ids;
-  const includeNamePattern = resolvedInclude?.namePattern;
-  const excludeNamePattern = resolvedExclude?.namePattern;
-  const hasInclude = !!(includeIds?.length || includeNamePattern);
-  const hasExclude = !!(excludeIds?.length || excludeNamePattern);
+  const includeFilters = resolvedInclude?.filters;
+  const excludeFilters = resolvedExclude?.filters;
+  const hasInclude = hasCriteria(includeFilters);
+  const hasExclude = hasCriteria(excludeFilters);
   if (hasInclude && hasExclude) {
     const includeSource = directional?.include ? `${operation}.include` : "include";
     const excludeSource = directional?.exclude ? `${operation}.exclude` : "exclude";
     throw new Error(
-      `Entity filter for '${operation}' resolved both ${includeSource} and ${excludeSource}. Use one or the other. If a top-level filter conflicts with a per-direction filter, set the unwanted direction to { ids: [] } to clear it.`
+      `Entity filter for '${operation}' resolved both ${includeSource} and ${excludeSource}. Use one or the other. If a top-level filter conflicts with a per-direction filter, set the unwanted direction to { filters: { type: 'ids', match: [] } } to clear it.`
     );
   }
-  return createEntityFilter(
-    { ids: includeIds, namePattern: includeNamePattern },
-    { ids: excludeIds, namePattern: excludeNamePattern }
-  );
+  return createEntityFilter(includeFilters, excludeFilters);
 }
 function createEntityFilter(include, exclude) {
-  const includeIds = Array.isArray(include) ? include : include?.ids;
-  const excludeIds = Array.isArray(exclude) ? exclude : exclude?.ids;
-  const includeNamePattern = Array.isArray(include) ? void 0 : include?.namePattern;
-  const excludeNamePattern = Array.isArray(exclude) ? void 0 : exclude?.namePattern;
-  const hasInclude = !!(includeIds?.length || includeNamePattern);
-  const hasExclude = !!(excludeIds?.length || excludeNamePattern);
+  const normalizedInclude = normalizeCriteria(include);
+  const normalizedExclude = normalizeCriteria(exclude);
+  const hasInclude = hasCriteria(normalizedInclude);
+  const hasExclude = hasCriteria(normalizedExclude);
   if (hasInclude && hasExclude) {
     throw new Error("Entity filter cannot have both `include` and `exclude` defined. Use one or the other.");
   }
   if (!hasInclude && !hasExclude) {
     return void 0;
   }
-  const includeRegex = includeNamePattern ? safeRegex(includeNamePattern) : void 0;
-  const excludeRegex = excludeNamePattern ? safeRegex(excludeNamePattern) : void 0;
   if (hasInclude) {
-    const includeSet = includeIds?.length ? new Set(includeIds) : void 0;
+    return buildMatcher(normalizedInclude, true);
+  }
+  return buildMatcher(normalizedExclude, false);
+}
+function normalizeCriteria(criteria) {
+  if (Array.isArray(criteria)) {
+    return criteria.length > 0 ? { type: "ids", match: criteria } : void 0;
+  }
+  return criteria;
+}
+var VALID_FILTER_TYPES = ["ids", "nameContains"];
+var VALID_FILTER_FIELDS = ["include", "exclude"];
+var VALID_DIRECTION_KEYS = ["pull", "push"];
+var VALID_ENTITY_CONFIG_KEYS = /* @__PURE__ */ new Set([...VALID_DIRECTION_KEYS, ...VALID_FILTER_FIELDS]);
+var VALID_FILTER_BLOCK_KEYS = ["filters"];
+function validateEntityConfig(entityConfig, operation) {
+  const validKeysLabel = [...VALID_ENTITY_CONFIG_KEYS].join(", ");
+  for (const key of Object.keys(entityConfig)) {
+    if (!VALID_ENTITY_CONFIG_KEYS.has(key)) {
+      const suggestion = VALID_DIRECTION_KEYS.find((valid) => key.startsWith(valid));
+      const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+      throw new Error(`Unknown entity filter key "${key}".${hint} Valid keys are: ${validKeysLabel}.`);
+    }
+  }
+  const directional = entityConfig[operation];
+  if (directional && typeof directional === "object") {
+    const validFilterLabel = VALID_FILTER_FIELDS.join(", ");
+    for (const key of Object.keys(directional)) {
+      if (!VALID_FILTER_FIELDS.includes(key)) {
+        throw new Error(
+          `Unknown key "${key}" in ${operation} filter config. Valid keys are: ${validFilterLabel}.`
+        );
+      }
+    }
+  }
+  for (const field of VALID_FILTER_FIELDS) {
+    validateFilterBlock(entityConfig[field], field);
+  }
+  if (directional && typeof directional === "object") {
+    for (const field of VALID_FILTER_FIELDS) {
+      validateFilterBlock(directional[field], `${operation}.${field}`);
+    }
+  }
+}
+function validateFilterBlock(value, label) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (typeof value === "string") {
+    throw new Error(
+      `"${label}" must be an object like { filters: { type: 'nameContains', match: '${value}' } }, not a plain string.`
+    );
+  }
+  if (Array.isArray(value)) {
+    throw new Error(
+      `"${label}" must be an object like { filters: { type: 'ids', match: [...] } }, not a plain array.`
+    );
+  }
+  if (typeof value !== "object") {
+    throw new Error(`"${label}" must be an object with a "filters" field, but got ${typeof value}.`);
+  }
+  const block = value;
+  if ("type" in block && "match" in block) {
+    throw new Error(
+      `"${label}" has "type" and "match" at the top level. Wrap them in a "filters" key: { filters: { type: '${block.type}', match: ... } }.`
+    );
+  }
+  const validBlockKeysLabel = VALID_FILTER_BLOCK_KEYS.join(", ");
+  for (const key of Object.keys(block)) {
+    if (!VALID_FILTER_BLOCK_KEYS.includes(key)) {
+      throw new Error(`Unknown key "${key}" in ${label}. Valid keys are: ${validBlockKeysLabel}.`);
+    }
+  }
+  if (block.filters !== void 0) {
+    validateFilterCriteria(block.filters, `${label}.filters`);
+  }
+}
+function validateFilterCriteria(value, label) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `${label} must be an object like { type: 'ids', match: [...] }, but got ${typeof value}.`
+    );
+  }
+  const criteria = value;
+  if (!criteria.type) {
+    throw new Error(
+      `${label} is missing required "type" field. Expected one of: ${VALID_FILTER_TYPES.join(", ")}.`
+    );
+  }
+  if (!VALID_FILTER_TYPES.includes(criteria.type)) {
+    throw new Error(
+      `${label} has unknown type "${criteria.type}". Expected one of: ${VALID_FILTER_TYPES.join(", ")}.`
+    );
+  }
+  if (criteria.type === "ids" && !Array.isArray(criteria.match)) {
+    throw new Error(
+      `${label} with type "ids" requires "match" to be a string array, but got ${typeof criteria.match}.`
+    );
+  }
+  if (criteria.type === "nameContains" && typeof criteria.match !== "string") {
+    throw new Error(
+      `${label} with type "nameContains" requires "match" to be a string, but got ${typeof criteria.match}.`
+    );
+  }
+}
+function hasCriteria(criteria) {
+  if (!criteria) {
+    return false;
+  }
+  if (criteria.type === "ids") {
+    return criteria.match.length > 0;
+  }
+  return criteria.match.length > 0;
+}
+function buildMatcher(criteria, isInclude) {
+  if (criteria.type === "ids") {
+    const idSet = new Set(criteria.match);
     return (obj) => {
       const ids = Array.isArray(obj.id) ? obj.id : [obj.id];
-      const matchesIds = includeSet ? ids.some((id) => includeSet.has(id)) : true;
-      const matchesName = includeRegex ? includeRegex.test(obj.displayName ?? "") : true;
-      return matchesIds && matchesName;
+      const matches = ids.some((id) => idSet.has(id));
+      return isInclude ? matches : !matches;
     };
   }
-  const excludeSet = excludeIds?.length ? new Set(excludeIds) : void 0;
+  const needle = criteria.match.toLowerCase();
   return (obj) => {
-    const ids = Array.isArray(obj.id) ? obj.id : [obj.id];
-    const matchesIds = excludeSet ? ids.some((id) => excludeSet.has(id)) : false;
-    const matchesName = excludeRegex ? excludeRegex.test(obj.displayName ?? "") : false;
-    return !(matchesIds || matchesName);
+    const matches = (obj.displayName ?? "").toLowerCase().includes(needle);
+    return isInclude ? matches : !matches;
   };
 }
-function safeRegex(pattern) {
-  try {
-    return new RegExp(pattern);
-  } catch {
-    throw new Error(
-      `Invalid namePattern regex: "${pattern}". Provide a valid JavaScript regular expression.`
-    );
-  }
-}
 
 // src/sync/fileSyncEngineDataSource.ts
 import { red } from "colorette";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/cli",
-  "version": "20.57.2-alpha.22+a76473d7ee",
+  "version": "20.57.2-alpha.24+b45bd27ec0",
   "description": "Uniform command line interface tool",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./cli.js",
@@ -28,13 +28,13 @@
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",
     "@thi.ng/mime": "^2.2.23",
-    "@uniformdev/assets": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/canvas": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/context": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/files": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/project-map": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/redirect": "20.57.2-alpha.22+a76473d7ee",
-    "@uniformdev/richtext": "20.57.2-alpha.22+a76473d7ee",
+    "@uniformdev/assets": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/canvas": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/context": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/files": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/project-map": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/redirect": "20.57.2-alpha.24+b45bd27ec0",
+    "@uniformdev/richtext": "20.57.2-alpha.24+b45bd27ec0",
     "call-bind": "^1.0.2",
     "colorette": "2.0.20",
     "cosmiconfig": "9.0.0",
@@ -81,5 +81,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a76473d7ee17e2c8745b1f240d670afb90108f36"
+  "gitHead": "b45bd27ec09cbc11c81b4abea2579548c5a57ed1"
 }