datagrok-tools 6.5.3 → 6.5.5

package/bin/commands/help.js

@@ -78,6 +78,8 @@ Usage: grok add <entity> <name>
 Add an object template to your package:
 
 grok add app <name>
+grok add app [name] --domain <schema>[.<table>]
+grok add app [name] --domain <path to schema.json>
 grok add connection <name>
 grok add detector <semantic-type-name>
 grok add function [tag] <name>
@@ -89,6 +91,15 @@ grok add tests
 
 Please note that entity names may only include letters and numbers
 
+--domain scaffolds a working browse/CRUD app over an entity-mapped domain table
+(\`grok.dapi.domains\`) from the \`@datagrok-libraries/domain-ui\` defaults. Give it
+one table (\`--domain grit.issue\`), a whole schema the package declares in
+\`databases/<schema>/schema.json\` (one app per table), or the path to a schema
+manifest to copy into the package. A fresh app package is two commands:
+
+grok create MyTracker
+cd MyTracker && grok add app --domain grit.issue
+
 Supported languages for scripts:
 javascript, julia, node, octave, python, r
 
@@ -113,12 +124,18 @@ Options:
 const HELP_API = `
 Usage: grok api
 
-Create wrapper functions for package scripts and queries
+Create wrapper functions for package scripts and queries.
+Packages with \`databases/<schema>/schema.json\` manifests also get typed domain
+clients in \`src/generated/db.ts\`.
 
 Options:
-[-v | --verbose]
+[-v | --verbose] [--ui]
 
 --verbose         Print detailed output
+--ui              Also generate \`src/generated/db-ui.ts\` — typed UI wrappers over
+                  \`@datagrok-libraries/domain-ui\` for every domain table. Once the
+                  file exists, plain \`grok api\` keeps it up to date; delete it to
+                  opt out again
 `;
 const HELP_CONFIG = `
 Usage: grok config

package/bin/commands/publish.js

@@ -73,6 +73,27 @@ function discoverDockerfiles(packageName, version, debug) {
   }
   return results;
 }
+
+// Folders that name a published image in container.json instead of shipping a Dockerfile.
+// Nothing is built or pushed for them; the server resolves the reference on deploy.
+function referencedImageDirs() {
+  const dockerfilesDir = _path.default.join(curDir, 'dockerfiles');
+  if (!_fs.default.existsSync(dockerfilesDir)) return [];
+  const results = [];
+  for (const entry of _fs.default.readdirSync(dockerfilesDir, {
+    withFileTypes: true
+  })) {
+    if (!entry.isDirectory() || _fs.default.existsSync(_path.default.join(dockerfilesDir, entry.name, 'Dockerfile'))) continue;
+    const configPath = _path.default.join(dockerfilesDir, entry.name, 'container.json');
+    if (!_fs.default.existsSync(configPath)) continue;
+    const image = JSON.parse(_fs.default.readFileSync(configPath, 'utf-8')).image;
+    if (image) results.push({
+      name: entry.name,
+      image
+    });
+  }
+  return results;
+}
 function dockerCommand(args) {
   return execSync(`docker ${args}`, {
     encoding: 'utf-8',
@@ -285,6 +306,7 @@ async function resolveLatestCompatible(host, devKey, dockerName, version, conten
   }
 }
 async function processDockerImages(packageName, version, registry, devKey, host, rebuildDocker, zip, localTimestamps, debug, skipDockerRebuild = false, generatedDirs = []) {
+  for (const dir of referencedImageDirs()) color.log(`dockerfiles/${dir.name} runs ${dir.image} — nothing to build`);
   const dockerImages = discoverDockerfiles(packageName, version, debug);
   if (dockerImages.length === 0) return;
   color.log(`Found ${dockerImages.length} Dockerfile(s)`);

package/bin/utils/ent-helpers.js

@@ -8,6 +8,18 @@ const app = appName => `
 The application ${appName} has been added successfully
 Read more at https://datagrok.ai/help/develop/how-to/build-an-app
 See application examples at https://public.datagrok.ai/apps`;
+const domainApp = (appNames, tables) => `
+The application${appNames.length > 1 ? 's' : ''} ${appNames.join(', ')} ` + `(over ${tables.join(', ')}) ${appNames.length > 1 ? 'have' : 'has'} been added successfully
+
+Next steps:
+  npm install                     install @datagrok-libraries/domain-ui
+  npm run build && grok publish   publish the package and open the app from the browse tree
+
+The app is the domain-ui defaults alone — list, search, entity page, editing,
+permissions and deep links. Customize through the options of the handle's factories
+(domains.table(...).app({actions: ...})), or register a DG.DomainObjectHandler for
+the table to change how its rows render.
+Read more at https://datagrok.ai/help/develop/how-to/build-an-app`;
 const connection = connectionName => `
 The connection ${connectionName} has been added successfully
 Read more at https://datagrok.ai/help/access/access#data-connection,
@@ -47,6 +59,7 @@ Run 'npm install' to get newly added packages
 Read more about package testing at https://datagrok.ai/help/develop/how-to/test-packages`;
 const help = exports.help = {
   app,
+  domainApp,
   connection,
   detector,
   func,

package/bin/utils/utils.js

@@ -34,6 +34,7 @@ exports.runAll = runAll;
 exports.runScript = runScript;
 exports.scriptWrapperTemplate = exports.scriptLangExtMap = exports.scriptExtensions = void 0;
 exports.setHost = setHost;
+exports.snakeToCamelCase = snakeToCamelCase;
 exports.spaceToCamelCase = spaceToCamelCase;
 exports.wordsToCamelCase = wordsToCamelCase;
 var _fs = _interopRequireDefault(require("fs"));
@@ -56,6 +57,10 @@ function kebabToCamelCase(s, firstUpper = true) {
   s = s.replace(/-./g, x => x.toUpperCase()[1]);
   return (firstUpper ? s[0].toUpperCase() : s[0].toLowerCase()) + s.slice(1);
 }
+function snakeToCamelCase(s, firstUpper = true) {
+  s = s.replace(/_./g, x => x[1].toUpperCase());
+  return (firstUpper ? s[0].toUpperCase() : s[0].toLowerCase()) + s.slice(1);
+}
 function descriptionToComment(s) {
   if (s.length === 0) return '';
   return '/**\n' + s + '\n*/\n';
@@ -126,6 +131,7 @@ const replacers = exports.replacers = {
   NAME_TITLECASE: (s, name) => s.replace(/#{NAME_TITLECASE}/g, name[0].toUpperCase() + name.slice(1).toLowerCase()),
   NAME_LOWERCASE: (s, name) => s.replace(/#{NAME_LOWERCASE}/g, name.toLowerCase()),
   NAME_PREFIX: (s, name) => s.replace(/#{NAME_PREFIX}/g, name.slice(0, 3)),
+  DOMAIN_TABLE: (s, table) => s.replace(/#{DOMAIN_TABLE}/g, table),
   PACKAGE_DETECTORS_NAME: (s, name) => s.replace(/#{PACKAGE_DETECTORS_NAME}/g, kebabToCamelCase(name)),
   PACKAGE_NAMESPACE: (s, name) => s.replace(/#{PACKAGE_NAMESPACE}/g, name),
   FUNC_DESCRIPTION: (s, desc) => s.replace(/#{FUNC_DESCRIPTION}/g, descriptionToComment(desc)),

package/domain-schema.schema.json

@@ -0,0 +1,253 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://datagrok.ai/schemas/domain-schema.schema.json",
+  "title": "Datagrok domain schema manifest",
+  "description": "Declares entity-mapped tables of a plugin database schema (databases/<schema>/schema.json). Tables get platform row/column security, Datlas-managed CRUD, and an in-transaction audit trail.",
+  "type": "object",
+  "required": ["name", "version", "tables"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {"type": "string"},
+    "name": {
+      "description": "Logical schema name; must match the databases/<name>/ directory.",
+      "$ref": "#/definitions/identifier"
+    },
+    "version": {
+      "type": "string",
+      "description": "Manifest version (semver recommended). Recorded in the registry on deploy."
+    },
+    "extensible": {
+      "type": "object",
+      "description": "Opt-in for user extensions of this schema. Users holding the Extend permission on the schema entity may then add their own tables; per-table column extension is opted in with the table's own 'extensible' flag. User objects are retained across plugin upgrades and never appear in generated typed clients.",
+      "required": ["tables"],
+      "additionalProperties": false,
+      "properties": {
+        "tables": {
+          "type": "boolean",
+          "description": "Whether users may add their own tables to this schema."
+        }
+      }
+    },
+    "tables": {
+      "type": "object",
+      "description": "Entity-mapped tables keyed by table name.",
+      "minProperties": 1,
+      "propertyNames": {"$ref": "#/definitions/identifier"},
+      "additionalProperties": {"$ref": "#/definitions/table"}
+    },
+    "propertySchemas": {
+      "type": "object",
+      "description": "Named groups of dynamic (jsonb) properties; grant a schema to a group to control column visibility.",
+      "propertyNames": {"$ref": "#/definitions/identifier"},
+      "additionalProperties": {
+        "type": "object",
+        "minProperties": 1,
+        "propertyNames": {"$ref": "#/definitions/columnName"},
+        "additionalProperties": {"$ref": "#/definitions/column"}
+      }
+    },
+    "migrations": {
+      "type": "object",
+      "description": "Explicit statements for destructive changes the diff engine refuses to apply automatically."
+    }
+  },
+  "definitions": {
+    "identifier": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_]*$",
+      "maxLength": 63
+    },
+    "columnName": {
+      "description": "An identifier that additionally may not start with 'x_' — that prefix is reserved for the physical names of user-added extension columns.",
+      "allOf": [
+        {"$ref": "#/definitions/identifier"},
+        {"not": {"type": "string", "pattern": "^x_"}}
+      ]
+    },
+    "table": {
+      "type": "object",
+      "required": ["columns"],
+      "additionalProperties": false,
+      "properties": {
+        "securityMode": {
+          "enum": ["table", "master", "row"],
+          "default": "table",
+          "description": "table: one check against the table entity; master: delegate to the master row via the delegate column; row: per-row grants with lazy/eager promotion."
+        },
+        "promotion": {
+          "enum": ["lazy", "eager"],
+          "default": "lazy",
+          "description": "Row mode only. lazy: entities row created on first share; eager: at insert."
+        },
+        "defaultRowVisibility": {
+          "enum": ["table", "none"],
+          "default": "table",
+          "description": "Row/master modes: whether table-level View shows unshared rows."
+        },
+        "delegate": {
+          "$ref": "#/definitions/identifier",
+          "description": "Master mode: the ref column whose target row's security applies."
+        },
+        "softDelete": {"type": "boolean", "default": true},
+        "audit": {
+          "type": "boolean",
+          "default": true,
+          "description": "Per-table in-transaction audit trail (before/after diffs, history, restore)."
+        },
+        "extensible": {
+          "type": "boolean",
+          "default": false,
+          "description": "Whether users holding Extend on this schema may add their own columns to this table. Such columns stay optional, non-unique, outside the business key, and may not cascade deletes; they are stored under an 'x_' physical prefix but addressed by their declared name everywhere."
+        },
+        "idempotency": {
+          "type": "boolean",
+          "default": false,
+          "description": "Adds the idempotency_key system column for replay-safe creates."
+        },
+        "ginIndex": {
+          "type": "boolean",
+          "default": false,
+          "description": "Adds a GIN (jsonb_path_ops) index on the data column."
+        },
+        "businessKey": {
+          "type": "array",
+          "items": {"$ref": "#/definitions/identifier"},
+          "minItems": 1,
+          "description": "Natural key: powers dedup-on-insert, upsert matching, and entity handles."
+        },
+        "friendlyName": {"type": "string"},
+        "description": {"type": "string"},
+        "singularName": {
+          "type": "string",
+          "maxLength": 256,
+          "description": "Explicit singular display name ('New <singular>...' buttons); defaults to a guess from the table name."
+        },
+        "pluralName": {
+          "type": "string",
+          "maxLength": 256,
+          "description": "Explicit plural display name (view titles); defaults to a guess from the table name."
+        },
+        "columns": {
+          "type": "object",
+          "description": "Relational columns keyed by column name. System columns (id, is_deleted, version, created_on, updated_on, author_id, idempotency_key, data) are generated and must not be declared.",
+          "propertyNames": {"$ref": "#/definitions/columnName"},
+          "additionalProperties": {"$ref": "#/definitions/column"}
+        },
+        "schemas": {
+          "type": "array",
+          "items": {"$ref": "#/definitions/identifier"},
+          "description": "Property schemas contributing jsonb keys to this table."
+        },
+        "relations": {
+          "type": "object",
+          "description": "Many-to-many relations of this table keyed by relation name: each links the table to a target table through a junction table. The name shares one namespace with the columns (it is what expand and filter paths address), so it may not collide with a column of this table. Declaration order is preserved and is the order every UI surface lays the relations out in.",
+          "propertyNames": {"$ref": "#/definitions/columnName"},
+          "additionalProperties": {"$ref": "#/definitions/relation"}
+        },
+        "filters": {
+          "type": "array",
+          "description": "Default filter panel for this table (entity filters): declared columns pre-open in order. Absent = heuristics by column type, INCLUDING one facet per travelable many-to-many relation. Declaring this section replaces the whole heuristic set, relation facets included — to keep one, list it explicitly as {\"column\": \"<relation>.id\"}.",
+          "items": {
+            "type": "object",
+            "required": ["column"],
+            "additionalProperties": false,
+            "properties": {
+              "column": {
+                "type": "string",
+                "description": "Column name, a filterable system column (id, author_id, created_on, updated_on, version), or a dotted forward FK path (e.g. 'category_id.name', max 3 hops)."
+              },
+              "type": {
+                "enum": ["categories", "histogram", "range", "text", "bool"],
+                "description": "Filter kind; defaults by column type. histogram/range need a numeric or datetime column, text a string column, bool a bool column."
+              },
+              "bins": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 200,
+                "description": "Histogram bin count (type histogram/range only)."
+              },
+              "label": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 256,
+                "description": "Display label for the filter; defaults to the column's friendly name."
+              }
+            }
+          }
+        }
+      }
+    },
+    "relation": {
+      "type": "object",
+      "required": ["via", "target"],
+      "additionalProperties": false,
+      "properties": {
+        "via": {
+          "$ref": "#/definitions/identifier",
+          "description": "Junction table declared in this manifest; differs from the owner and the target table. Its businessKey must contain both FK columns — that is what keeps re-linking the same pair idempotent."
+        },
+        "target": {
+          "$ref": "#/definitions/identifier",
+          "description": "Related table declared in this manifest."
+        },
+        "viaSelf": {
+          "$ref": "#/definitions/identifier",
+          "description": "Junction ref column pointing back at the owner table; may be omitted when the junction has exactly one such column. Self-referential relations must declare it."
+        },
+        "viaTarget": {
+          "$ref": "#/definitions/identifier",
+          "description": "Junction ref column pointing at the target table; may be omitted when the junction has exactly one such column. Self-referential relations must declare it."
+        },
+        "allowCreate": {
+          "type": "boolean",
+          "default": true,
+          "description": "Whether the UI may create a target row on the fly while linking (still subject to create permission on the target table)."
+        }
+      }
+    },
+    "column": {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "enum": ["string", "int", "float", "bool", "datetime", "string_list", "ref", "user", "group", "file"],
+          "description": "Property type; ref = FK to another table in this manifest; user/group = FK to the core users/groups tables with the matching semantic type; file = a file://<connection>/<path> string into platform file storage (semantic type File)."
+        },
+        "required": {"type": "boolean", "default": false},
+        "unique": {
+          "type": "boolean",
+          "default": false,
+          "description": "Unique among live (not soft-deleted) rows."
+        },
+        "isName": {
+          "type": "boolean",
+          "default": false,
+          "description": "Marks the primary display-name column (string columns only; at most one per table). Its value titles cards, tooltips, and entity views, and becomes the friendly name of promoted rows. Convention fallback: a string column literally named 'name'."
+        },
+        "ref": {
+          "$ref": "#/definitions/identifier",
+          "description": "Target table name (type = ref only). Cross-plugin refs are not allowed."
+        },
+        "onDelete": {
+          "enum": ["cascade", "restrict", "setnull"],
+          "description": "Engine-enforced referential action on soft delete (ref/user/group columns)."
+        },
+        "min": {"type": "number"},
+        "max": {"type": "number"},
+        "choices": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Controlled dictionary of allowed values."
+        },
+        "semType": {"type": "string"},
+        "friendlyName": {"type": "string"},
+        "description": {"type": "string"},
+        "default": {
+          "description": "Default value for new rows / UI inputs."
+        },
+        "format": {"type": "string"}
+      }
+    }
+  }
+}

package/entity-template/domain-app.js

@@ -0,0 +1,11 @@
+
+//name: #{NAME}
+//description: Browse and edit #{DOMAIN_TABLE} rows
+//meta.role: app
+//input: string path {meta.url: true; optional: true}
+//output: view result
+export async function #{NAME}() {
+  // The declared `path` input is what makes the app URL-addressable; the page
+  // reads the deep link itself (restoreFromUrl), so the function takes no parameter.
+  return (await domains.table('#{DOMAIN_TABLE}')).app();
+}

package/entity-template/domain-app.ts

@@ -0,0 +1,11 @@
+
+//name: #{NAME}
+//description: Browse and edit #{DOMAIN_TABLE} rows
+//meta.role: app
+//input: string path {meta.url: true; optional: true}
+//output: view result
+export async function #{NAME}(): Promise<DG.ViewBase> {
+  // The declared `path` input is what makes the app URL-addressable; the page
+  // reads the deep link itself (restoreFromUrl), so the function takes no parameter.
+  return (await domains.table('#{DOMAIN_TABLE}')).app();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.5.3",
+  "version": "6.5.5",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {
@@ -10,6 +10,7 @@
     "@typescript-eslint/typescript-estree": "^8.61.1",
     "@typescript-eslint/visitor-keys": "^8.61.1",
     "adm-zip": "^0.6.0",
+    "ajv": "^8.20.0",
     "archiver": "^7.0.1",
     "datagrok-api": "^1.27.6",
     "estraverse": "^5.3.0",

package/plugins/func-gen-plugin.js

@@ -84,17 +84,23 @@ function preparseIvpModel(parser, text) {
   const viewer = `Grid(block: 100) | Line chart(block: 100, multiAxis: "${multiAxis}",${segments} ` +
     `multiAxisLegendPosition: "RightCenter", autoLayout: "false", showAggrSelectors: "false")` +
     ` | DiffStudio Facet(block: 100${facetSegment})`;
-  const outputAnnotation = `//output: dataframe df {caption: ${ivp.name}; viewer: ${viewer}}`;
-
   const metas = {runOnOpen: 'true', runOnInput: 'true', features: '{"sens-analysis": true, "fitting": true}'};
   let isModel = false;
+  let comparison = null;
   for (const meta of ivp.metas || []) {
     const m = /^(?:\/\/)?meta\.([\w-]+):\s*(.*)$/.exec(String(meta).trim());
     if (!m) continue;
     if (m[1] === 'role') {
       if (m[2].split(',').map((s) => s.trim()).includes('model')) isModel = true;
+    } else if (m[1] === 'comparison') {
+      // run comparison reads the {comparison: ...} JSON off the dataframe output's
+      // options, not off function-level meta
+      comparison = m[2];
     } else if (m[1] !== 'solver') metas[m[1]] = m[2];
   }
+
+  const outputAnnotation = `//output: dataframe df {caption: ${ivp.name}; ` +
+    `${comparison ? `comparison: ${comparison}; ` : ''}viewer: ${viewer}}`;
   // Convert a `#meta.inputs` lookup into a real `propagateChoice: all` string input. RFV renders
   // this natively (it ignores `meta.inputs`); selecting a row fills the matching inputs by name.
   // Name / brace parsing mirrors DiffStudio's getLookupsInfo (utils.ts): the name is the text

package/bin/__tests__/build.test.js

@@ -1,116 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _build = require("../commands/build");
-(0, _vitest.describe)('getNestedValue', () => {
-  (0, _vitest.it)('returns value for a simple key', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      name: 'Chem'
-    }, 'name')).toBe('Chem');
-  });
-  (0, _vitest.it)('returns value for a nested path', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      a: {
-        b: {
-          c: 42
-        }
-      }
-    }, 'a.b.c')).toBe(42);
-  });
-  (0, _vitest.it)('returns undefined for a missing key', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      name: 'Chem'
-    }, 'version')).toBeUndefined();
-  });
-  (0, _vitest.it)('returns undefined when a mid-path segment is null', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      a: null
-    }, 'a.b')).toBeUndefined();
-  });
-  (0, _vitest.it)('returns undefined when a mid-path segment is missing', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      a: {}
-    }, 'a.b.c')).toBeUndefined();
-  });
-  (0, _vitest.it)('returns undefined for an empty path (splits to empty string key)', () => {
-    (0, _vitest.expect)((0, _build.getNestedValue)({
-      x: 1
-    }, '')).toBeUndefined();
-  });
-});
-const pkg = overrides => ({
-  dir: '/tmp/pkg',
-  name: overrides.name ?? 'test-pkg',
-  friendlyName: overrides.friendlyName ?? overrides.name ?? 'Test Pkg',
-  version: overrides.version ?? '1.0.0',
-  packageJson: overrides
-});
-(0, _vitest.describe)('applyFilter', () => {
-  const packages = [pkg({
-    name: 'Chem',
-    version: '1.5.0',
-    category: 'Cheminformatics'
-  }), pkg({
-    name: 'Bio',
-    version: '2.0.0',
-    category: 'Bioinformatics'
-  }), pkg({
-    name: 'PowerGrid',
-    version: '1.5.0',
-    category: 'Viewers'
-  })];
-  (0, _vitest.it)('returns all packages when filter matches all', () => {
-    (0, _vitest.expect)((0, _build.applyFilter)(packages, 'name:.')).toHaveLength(3);
-  });
-  (0, _vitest.it)('filters by exact name match', () => {
-    const result = (0, _build.applyFilter)(packages, 'name:^Chem$');
-    (0, _vitest.expect)(result).toHaveLength(1);
-    (0, _vitest.expect)(result[0].name).toBe('Chem');
-  });
-  (0, _vitest.it)('filters by partial name (regex substring)', () => {
-    const result = (0, _build.applyFilter)(packages, 'name:Bio');
-    (0, _vitest.expect)(result).toHaveLength(1);
-    (0, _vitest.expect)(result[0].name).toBe('Bio');
-  });
-  (0, _vitest.it)('returns empty array when nothing matches', () => {
-    (0, _vitest.expect)((0, _build.applyFilter)(packages, 'name:NOMATCH')).toHaveLength(0);
-  });
-  (0, _vitest.it)('filters by version', () => {
-    const result = (0, _build.applyFilter)(packages, 'version:^1\\.5');
-    (0, _vitest.expect)(result).toHaveLength(2);
-    (0, _vitest.expect)(result.map(p => p.name)).toEqual(_vitest.expect.arrayContaining(['Chem', 'PowerGrid']));
-  });
-  (0, _vitest.it)('applies && conjunction (both conditions must match)', () => {
-    const result = (0, _build.applyFilter)(packages, 'name:Chem && version:1\\.5');
-    (0, _vitest.expect)(result).toHaveLength(1);
-    (0, _vitest.expect)(result[0].name).toBe('Chem');
-  });
-  (0, _vitest.it)('returns empty when one part of && conjunction fails', () => {
-    (0, _vitest.expect)((0, _build.applyFilter)(packages, 'name:Chem && version:^2')).toHaveLength(0);
-  });
-  (0, _vitest.it)('filters by nested field', () => {
-    const withNested = [pkg({
-      name: 'A',
-      datagrok: {
-        apiVersion: '1.0'
-      }
-    }), pkg({
-      name: 'B',
-      datagrok: {
-        apiVersion: '2.0'
-      }
-    })];
-    const result = (0, _build.applyFilter)(withNested, 'datagrok.apiVersion:^1');
-    (0, _vitest.expect)(result).toHaveLength(1);
-    (0, _vitest.expect)(result[0].name).toBe('A');
-  });
-  (0, _vitest.it)('returns empty when field does not exist', () => {
-    (0, _vitest.expect)((0, _build.applyFilter)(packages, 'nonexistent:anything')).toHaveLength(0);
-  });
-  (0, _vitest.it)('treats filter with no colon as field name with match-all pattern', () => {
-    // No colon → field = whole string, pattern = /./  (matches any value)
-    // The function returns packages where the field exists and is non-empty
-    const result = (0, _build.applyFilter)(packages, 'name');
-    (0, _vitest.expect)(result).toHaveLength(3);
-  });
-});