datagrok-tools 6.5.4 → 6.5.6

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/commands/report.js

@@ -367,10 +367,10 @@ async function handleTicket(args) {
   const issueType = args['type'] || 'Bug';
   const auth = jiraAuthHeader();
   if (auth == null) {
-    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report ticket`.');
+    color.error('Set JIRA_TOKEN (plus JIRA_USER for a user API token) for `grok report ticket`.');
     return false;
   }
-  const jiraBase = resolveJiraBase(args);
+  const jiraBase = await resolveJiraBase(args);
   try {
     const {
       url,
@@ -444,10 +444,23 @@ async function handleTicket(args) {
 
 // ─── JIRA REST helpers (used by `grok report comment` / `grok report label`) ─
 //
-// These talk DIRECTLY to Atlassian Cloud REST v2 (not Datagrok). Auth is HTTP
-// Basic with `JIRA_USER` (Atlassian email) + `JIRA_TOKEN` (API token from
-// id.atlassian.com/manage-profile/security/api-tokens). Base URL defaults to
-// the Datagrok org instance; override via --jira-url or $JIRA_URL.
+// These talk DIRECTLY to Atlassian Cloud REST v2 (not Datagrok). Two auth schemes, picked from
+// the token itself:
+//
+//   * user API token (`ATATT...`, from id.atlassian.com/manage-profile/security/api-tokens) —
+//     HTTP Basic with `JIRA_USER` + `JIRA_TOKEN`, against the site. The original path.
+//   * service-account token (`ATSTT...`, from admin.atlassian.com) — a SCOPED token. The site
+//     host will not take it: Basic gives 401, and Bearer gives 403 "Failed to parse Connect
+//     Session Auth Token" because Jira tries to read it as a Connect session. Only the API
+//     gateway accepts it, addressed by cloud id, with Bearer. No JIRA_USER is involved.
+//
+// Both are supported on purpose. Automation moved to a service account when its bot mailbox
+// became a Google group (a group holds no Atlassian identity and cannot mint tokens), while
+// release-notes CI and every developer's local setup still use user tokens.
+//
+// Base URL defaults to the Datagrok org instance; override via --jira-url or $JIRA_URL. That
+// value stays the SITE — the gateway address is derived from it, never substituted for it, so
+// human-facing links elsewhere keep working.
 //
 // Why v2 and not v3: v3 requires comment bodies in ADF (Atlassian Document
 // Format) JSON, which is much heavier to construct. v2 accepts a plain string
@@ -455,15 +468,49 @@ async function handleTicket(args) {
 // becomes a top-level ordered-list item, ` ` shows up literally, etc.
 // `markdownToJiraWiki` below bridges the gap for Markdown-emitting callers.
 
-function resolveJiraBase(args) {
+const JIRA_SERVICE_TOKEN_RE = /^ATSTT/;
+function isJiraServiceToken() {
+  return JIRA_SERVICE_TOKEN_RE.test(process.env.JIRA_TOKEN || '');
+}
+
+// The site, as configured. Human-facing links are built from this.
+function resolveJiraSite(args) {
   const cli = args['jira-url'] || '';
   const env = process.env.JIRA_URL || '';
   return (cli || env || 'https://reddata.atlassian.net').replace(/\/+$/, '');
 }
+let cloudIdCache = null;
+
+// The gateway addresses a site by cloud id rather than hostname. Public endpoint, no credentials
+// needed, cached for the process.
+async function resolveJiraCloudId(site) {
+  if (process.env.JIRA_CLOUD_ID) return process.env.JIRA_CLOUD_ID.trim();
+  if (cloudIdCache !== null) return cloudIdCache;
+  try {
+    const r = await fetch(`${site}/_edge/tenant_info`);
+    const j = r.ok ? await r.json() : {};
+    cloudIdCache = (j.cloudId || '').trim();
+  } catch {
+    cloudIdCache = '';
+  }
+  return cloudIdCache;
+}
+
+// Where REST calls go. A service token needs the gateway; anything else keeps the site. If the
+// cloud id cannot be resolved, fall back to the site rather than failing outright — the request
+// then reports a normal auth error instead of a confusing lookup one.
+async function resolveJiraBase(args) {
+  const site = resolveJiraSite(args);
+  if (!isJiraServiceToken()) return site;
+  const cloudId = await resolveJiraCloudId(site);
+  return cloudId ? `https://api.atlassian.com/ex/jira/${cloudId}` : site;
+}
 function jiraAuthHeader() {
-  const user = process.env.JIRA_USER;
   const token = process.env.JIRA_TOKEN;
-  if (!user || !token) return null;
+  if (!token) return null;
+  if (isJiraServiceToken()) return `Bearer ${token}`;
+  const user = process.env.JIRA_USER;
+  if (!user) return null;
   return 'Basic ' + Buffer.from(`${user}:${token}`).toString('base64');
 }
 
@@ -544,7 +591,7 @@ async function handleComment(args) {
   }
   const auth = jiraAuthHeader();
   if (auth == null) {
-    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report comment`.');
+    color.error('Set JIRA_TOKEN (plus JIRA_USER for a user API token) for `grok report comment`.');
     return false;
   }
   let body;
@@ -566,7 +613,7 @@ async function handleComment(args) {
     color.error('Comment body is empty (use --body, --body-file, or pipe to stdin).');
     return false;
   }
-  const base = resolveJiraBase(args);
+  const base = await resolveJiraBase(args);
   const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}/comment`;
   // Callers (especially the dg-fix-reports M2 handoff) emit Markdown, but JIRA
   // REST v2 renders the body as wiki markup. Convert before posting so headings,
@@ -614,13 +661,15 @@ async function handleAttach(args) {
     color.error(`File not found: ${filePath}`);
     return false;
   }
-  const user = process.env.JIRA_USER;
-  const token = process.env.JIRA_TOKEN;
-  if (!user || !token) {
-    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report attach`.');
+
+  // Through the same helper as every other call: a service token authenticates with Bearer and
+  // has no JIRA_USER at all, so checking for one here would refuse a working setup.
+  const auth = jiraAuthHeader();
+  if (auth == null) {
+    color.error('Set JIRA_TOKEN (plus JIRA_USER for a user API token) for `grok report attach`.');
     return false;
   }
-  const base = resolveJiraBase(args);
+  const base = await resolveJiraBase(args);
   const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}/attachments`;
 
   // node-fetch v2 has no built-in FormData and the codebase doesn't depend on
@@ -630,7 +679,7 @@ async function handleAttach(args) {
   const {
     spawnSync
   } = require('child_process');
-  const r = spawnSync('curl', ['-sS', '-X', 'POST', '-u', `${user}:${token}`, '-H', 'X-Atlassian-Token: no-check', '-F', `file=@${filePath}`, '-w', '\n%{http_code}\n', url], {
+  const r = spawnSync('curl', ['-sS', '-X', 'POST', '-H', `Authorization: ${auth}`, '-H', 'X-Atlassian-Token: no-check', '-F', `file=@${filePath}`, '-w', '\n%{http_code}\n', url], {
     encoding: 'utf8',
     timeout: 120_000,
     maxBuffer: 4 * 1024 * 1024
@@ -671,10 +720,10 @@ async function handleLabel(args) {
   }
   const auth = jiraAuthHeader();
   if (auth == null) {
-    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report label`.');
+    color.error('Set JIRA_TOKEN (plus JIRA_USER for a user API token) for `grok report label`.');
     return false;
   }
-  const base = resolveJiraBase(args);
+  const base = await resolveJiraBase(args);
   const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}`;
   const update = {
     labels: labels.map(l => ({

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.4",
+  "version": "6.5.6",
   "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",