@softr/cli 0.1.4 → 0.1.5

package/README.md

@@ -222,26 +222,41 @@ schema refresh the cache too; the CLI rewrites it at any time, so never edit it.
 ```
 crm/
   softr-db.jsonc               # { "databaseId": "…" }
-  .softr-db/schema.json        # the cache
+  .softr-db/schema.json        # the cache of the tables and fields
+  .softr-db/views/<tableId>.json  # the views of a table, once views list read them
 ```
 
-| Command                                                                          | What it does                                                                                                                                                                                    |
-| -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `db list`                                                                        | The databases the token reaches, across all workspaces, with their workspace and number of tables.                                                                                              |
-| `db get [<database>] [--dir <path>]`                                             | One database with its tables, by id or exact name. Outside a database directory it creates `./<name-slug>/`; inside one it refreshes the cache, and a different database is an error.           |
-| `db create <name> [--description <text>] [--workspace <id>] [--dir <path>]`      | Create an empty database and its directory. The workspace defaults to `SOFTR_WORKSPACE_ID`, else to your only or default workspace among those where the token grants `databases.schema:write`. |
-| `db update [<databaseId>] [--name <name>] [--description <text>] [--dir <path>]` | Change the name, the description or both.                                                                                                                                                       |
-| `db delete [<databaseId>] [--force] [--dir <path>]`                              | Delete a database. One that still has tables needs `--force`, which also deletes the tables and all their records. The directory keeps its `softr-db.jsonc`; the cache goes.                    |
+| Command                                                                                       | What it does                                                                                                                                                                                    |
+| --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `db list`                                                                                     | The databases the token reaches, across all workspaces, with their workspace and number of tables.                                                                                              |
+| `db get [<database>] [--dir <path>]`                                                          | One database with its tables, by id or exact name. Outside a database directory it creates `./<name-slug>/`; inside one it refreshes the cache, and a different database is an error.           |
+| `db create <name> [--description <text>] [--workspace <id>] [--dir <path>]`                   | Create an empty database and its directory. The workspace defaults to `SOFTR_WORKSPACE_ID`, else to your only or default workspace among those where the token grants `databases.schema:write`. |
+| `db update [<databaseId>] [--name <name>] [--description <text>] [--dir <path>]`              | Change the name, the description or both.                                                                                                                                                       |
+| `db delete [<databaseId>] [--force] [--dir <path>]`                                           | Delete a database. One that still has tables needs `--force`, which also deletes the tables and all their records. The directory keeps its `softr-db.jsonc`; the cache goes.                    |
+| `db tables list` / `get <table>`                                                              | The tables of the database; one table with its fields (ids, types, primary/required/read-only).                                                                                                 |
+| `db tables create <name> [--field <name:TYPE>]... [--fields <json>] [--primary-field <name>]` | Create a table with at least one field: `--field` for types without options, `--fields` (a JSON array, `@<file>` or `-`) for any; the first one names a record.                                 |
+| `db tables update <table> [--name] [--description]` / `delete <table> [--force]`              | Rename or describe a table; delete it (`--force` when it still has records).                                                                                                                    |
+| `db fields get <table> <field>`                                                               | One field with its options.                                                                                                                                                                     |
+| `db fields add <table> <name> --type <TYPE> [--options <json>] [--multiple]`                  | Add a field. The types and their options: [field reference](https://docs.softr.io/softr-api/softr-database-api/table-fields/add-table-field).                                                   |
+| `db fields update <table> <field> [--name] [--type] [--options <json>] [--[no-]multiple]`     | Change a field; what is not passed stays as it is, `--options` replaces the options as a whole.                                                                                                 |
+| `db fields delete <table> <field>`                                                            | Delete a field and its values in every record.                                                                                                                                                  |
+| `db views list <table>`                                                                       | The views of a table (the API reads views only).                                                                                                                                                |
+
+Tables and fields take an id or an exact name; a name two items share is an error that lists their ids. The table,
+field and view commands take the database from `--database <id>`, else `SOFTR_DATABASE_ID`, else the database
+directory, and keep its cache current; a delete always resolves the name on the server, never from the cache.
 
 ## Agent skills
 
-Two skills in the [Agent Skills](https://agentskills.io) format, published in
+Three skills in the [Agent Skills](https://agentskills.io) format, published in
 [softr-io/softr-io-skills](https://github.com/softr-io/softr-io-skills):
 
 - [`softr-cli`](https://github.com/softr-io/softr-io-skills/tree/master/skills/softr-cli): install and update the CLI,
   log in, the root commands and the environment variables. Every other Softr skill builds on it.
 - [`softr-workflows`](https://github.com/softr-io/softr-io-skills/tree/master/skills/softr-workflows): the
   `softr workflows` scope, with the code-file rules in its `references/custom-code.md`.
+- [`softr-db`](https://github.com/softr-io/softr-io-skills/tree/master/skills/softr-db): the `softr db` scope, the
+  database directory and the schema commands.
 
 Install them as a plugin in Claude Code, which keeps them updated, or with `npx skills add softr-io/softr-io-skills`
 in every other agent. The exact steps are on [docs.softr.io/softr-cli](https://docs.softr.io/softr-cli).

package/dist/cli.mjs

@@ -1745,7 +1745,7 @@ var require_table = __commonJS({
     var debug = require_debug();
     var utils = require_utils();
     var tableLayout = require_layout_manager();
-    var Table8 = class extends Array {
+    var Table9 = class extends Array {
       constructor(opts) {
         super();
         const options = utils.mergeOptions(opts);
@@ -1820,7 +1820,7 @@ var require_table = __commonJS({
         return str[0].length;
       }
     };
-    Table8.reset = () => debug.reset();
+    Table9.reset = () => debug.reset();
     function doDraw(row, lineNum, result) {
       let line = [];
       row.forEach(function(cell) {
@@ -1829,7 +1829,7 @@ var require_table = __commonJS({
       let str = line.join("");
       if (str.length) result.push(str);
     }
-    module.exports = Table8;
+    module.exports = Table9;
   }
 });
 
@@ -2598,14 +2598,14 @@ var Option = class {
    * @param {string} flags
    * @param {string} [description]
    */
-  constructor(flags, description) {
-    this.flags = flags;
+  constructor(flags2, description) {
+    this.flags = flags2;
     this.description = description || "";
-    this.required = flags.includes("<");
-    this.optional = flags.includes("[");
-    this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+    this.required = flags2.includes("<");
+    this.optional = flags2.includes("[");
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags2);
     this.mandatory = false;
-    const optionFlags = splitOptionFlags(flags);
+    const optionFlags = splitOptionFlags(flags2);
     this.short = optionFlags.shortFlag;
     this.long = optionFlags.longFlag;
     this.negate = false;
@@ -2856,12 +2856,12 @@ function camelcase(str) {
     return str2 + word[0].toUpperCase() + word.slice(1);
   });
 }
-function splitOptionFlags(flags) {
+function splitOptionFlags(flags2) {
   let shortFlag;
   let longFlag;
   const shortFlagExp = /^-[^-]$/;
   const longFlagExp = /^--[^-]/;
-  const flagParts = flags.split(/[ |,]+/).concat("guard");
+  const flagParts = flags2.split(/[ |,]+/).concat("guard");
   if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
   if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
   if (!shortFlag && shortFlagExp.test(flagParts[0]))
@@ -2872,7 +2872,7 @@ function splitOptionFlags(flags) {
   }
   if (flagParts[0].startsWith("-")) {
     const unsupportedFlag = flagParts[0];
-    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags2}'`;
     if (/^-[^-][^-]/.test(unsupportedFlag))
       throw new Error(
         `${baseError}
@@ -2891,7 +2891,7 @@ function splitOptionFlags(flags) {
   }
   if (shortFlag === void 0 && longFlag === void 0)
     throw new Error(
-      `option creation failed due to no flags found in '${flags}'.`
+      `option creation failed due to no flags found in '${flags2}'.`
     );
   return { shortFlag, longFlag };
 }
@@ -3454,8 +3454,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {Option} new option
    */
-  createOption(flags, description) {
-    return new Option(flags, description);
+  createOption(flags2, description) {
+    return new Option(flags2, description);
   }
   /**
    * Wrap parseArgs to catch 'commander.invalidArgument'.
@@ -3570,13 +3570,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @return {Command} `this` command for chaining
    * @private
    */
-  _optionEx(config, flags, description, fn, defaultValue) {
-    if (typeof flags === "object" && flags instanceof Option) {
+  _optionEx(config, flags2, description, fn, defaultValue) {
+    if (typeof flags2 === "object" && flags2 instanceof Option) {
       throw new Error(
         "To add an Option object use addOption() instead of option() or requiredOption()"
       );
     }
-    const option = this.createOption(flags, description);
+    const option = this.createOption(flags2, description);
     option.makeOptionMandatory(!!config.mandatory);
     if (typeof fn === "function") {
       option.default(defaultValue).argParser(fn);
@@ -3613,8 +3613,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {*} [defaultValue]
    * @return {Command} `this` command for chaining
    */
-  option(flags, description, parseArg, defaultValue) {
-    return this._optionEx({}, flags, description, parseArg, defaultValue);
+  option(flags2, description, parseArg, defaultValue) {
+    return this._optionEx({}, flags2, description, parseArg, defaultValue);
   }
   /**
    * Add a required option which must have a value after parsing. This usually means
@@ -3628,10 +3628,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {*} [defaultValue]
    * @return {Command} `this` command for chaining
    */
-  requiredOption(flags, description, parseArg, defaultValue) {
+  requiredOption(flags2, description, parseArg, defaultValue) {
     return this._optionEx(
       { mandatory: true },
-      flags,
+      flags2,
       description,
       parseArg,
       defaultValue
@@ -3798,18 +3798,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
    *
    * @private
    */
-  _prepareUserArgs(argv, parseOptions) {
+  _prepareUserArgs(argv, parseOptions2) {
     if (argv !== void 0 && !Array.isArray(argv)) {
       throw new Error("first parameter to parse must be array or undefined");
     }
-    parseOptions = parseOptions || {};
-    if (argv === void 0 && parseOptions.from === void 0) {
+    parseOptions2 = parseOptions2 || {};
+    if (argv === void 0 && parseOptions2.from === void 0) {
       if (process2.versions?.electron) {
-        parseOptions.from = "electron";
+        parseOptions2.from = "electron";
       }
       const execArgv = process2.execArgv ?? [];
       if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-        parseOptions.from = "eval";
+        parseOptions2.from = "eval";
       }
     }
     if (argv === void 0) {
@@ -3817,7 +3817,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     this.rawArgs = argv.slice();
     let userArgs;
-    switch (parseOptions.from) {
+    switch (parseOptions2.from) {
       case void 0:
       case "node":
         this._scriptPath = argv[1];
@@ -3839,7 +3839,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         break;
       default:
         throw new Error(
-          `unexpected parse option { from: '${parseOptions.from}' }`
+          `unexpected parse option { from: '${parseOptions2.from}' }`
         );
     }
     if (!this._name && this._scriptPath)
@@ -3869,9 +3869,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
    * @return {Command} `this` command for chaining
    */
-  parse(argv, parseOptions) {
+  parse(argv, parseOptions2) {
     this._prepareForParse();
-    const userArgs = this._prepareUserArgs(argv, parseOptions);
+    const userArgs = this._prepareUserArgs(argv, parseOptions2);
     this._parseCommand([], userArgs);
     return this;
   }
@@ -3895,9 +3895,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
    * @return {Promise}
    */
-  async parseAsync(argv, parseOptions) {
+  async parseAsync(argv, parseOptions2) {
     this._prepareForParse();
-    const userArgs = this._prepareUserArgs(argv, parseOptions);
+    const userArgs = this._prepareUserArgs(argv, parseOptions2);
     await this._parseCommand([], userArgs);
     return this;
   }
@@ -4748,12 +4748,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments
    */
-  version(str, flags, description) {
+  version(str, flags2, description) {
     if (str === void 0) return this._version;
     this._version = str;
-    flags = flags || "-V, --version";
+    flags2 = flags2 || "-V, --version";
     description = description || "output the version number";
-    const versionOption = this.createOption(flags, description);
+    const versionOption = this.createOption(flags2, description);
     this._versionOptionName = versionOption.attributeName();
     this._registerOption(versionOption);
     this.on("option:" + versionOption.name(), () => {
@@ -5055,9 +5055,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {Command} `this` command for chaining
    */
-  helpOption(flags, description) {
-    if (typeof flags === "boolean") {
-      if (flags) {
+  helpOption(flags2, description) {
+    if (typeof flags2 === "boolean") {
+      if (flags2) {
         if (this._helpOption === null) this._helpOption = void 0;
         if (this._defaultOptionGroup) {
           this._initOptionGroup(this._getHelpOption());
@@ -5068,10 +5068,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     this._helpOption = this.createOption(
-      flags ?? "-h, --help",
+      flags2 ?? "-h, --help",
       description ?? "display help for command"
     );
-    if (flags || description) this._initOptionGroup(this._helpOption);
+    if (flags2 || description) this._initOptionGroup(this._helpOption);
     return this;
   }
   /**
@@ -6177,6 +6177,9 @@ function globalOptions(command) {
 function emit(options, human, data2) {
   process.stdout.write(options.json ? JSON.stringify(data2, null, 2) + "\n" : human + "\n");
 }
+function plainTable(head, colWidths) {
+  return { head, colWidths, wordWrap: true, style: { head: [], border: [], "padding-left": 1, "padding-right": 1 } };
+}
 function reportError(error) {
   if (error instanceof CliError || error instanceof SoftrApiError) {
     process.stderr.write(`Error: ${error.message}
@@ -7636,8 +7639,8 @@ function parseJsoncFile(file, text) {
 async function listSubdirsWith(cwd, holds) {
   const entries = await readdir(cwd, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(cwd, entry.name));
-  const flags = await Promise.all(dirs.map((dir) => holds(dir)));
-  return dirs.filter((_, index) => flags[index]);
+  const flags2 = await Promise.all(dirs.map((dir) => holds(dir)));
+  return dirs.filter((_, index) => flags2[index]);
 }
 async function readConfig(dir) {
   const file = configPath(dir);
@@ -8284,12 +8287,12 @@ prototypeAccessors.inAsync.get = function() {
 prototypeAccessors.canAwait.get = function() {
   for (var i2 = this.scopeStack.length - 1; i2 >= 0; i2--) {
     var ref2 = this.scopeStack[i2];
-    var flags = ref2.flags;
-    if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) {
+    var flags2 = ref2.flags;
+    if (flags2 & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) {
       return false;
     }
-    if (flags & SCOPE_FUNCTION) {
-      return (flags & SCOPE_ASYNC) > 0;
+    if (flags2 & SCOPE_FUNCTION) {
+      return (flags2 & SCOPE_ASYNC) > 0;
     }
   }
   return this.inModule && this.options.ecmaVersion >= 13 || this.options.allowAwaitOutsideFunction;
@@ -8305,8 +8308,8 @@ prototypeAccessors.allowReturn.get = function() {
 };
 prototypeAccessors.allowSuper.get = function() {
   var ref2 = this.currentThisScope();
-  var flags = ref2.flags;
-  return (flags & SCOPE_SUPER) > 0 || this.options.allowSuperOutsideMethod;
+  var flags2 = ref2.flags;
+  return (flags2 & SCOPE_SUPER) > 0 || this.options.allowSuperOutsideMethod;
 };
 prototypeAccessors.allowDirectSuper.get = function() {
   return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0;
@@ -8317,8 +8320,8 @@ prototypeAccessors.treatFunctionsAsVar.get = function() {
 prototypeAccessors.allowNewDotTarget.get = function() {
   for (var i2 = this.scopeStack.length - 1; i2 >= 0; i2--) {
     var ref2 = this.scopeStack[i2];
-    var flags = ref2.flags;
-    if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || flags & SCOPE_FUNCTION && !(flags & SCOPE_ARROW)) {
+    var flags2 = ref2.flags;
+    if (flags2 & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || flags2 & SCOPE_FUNCTION && !(flags2 & SCOPE_ARROW)) {
       return true;
     }
   }
@@ -8326,11 +8329,11 @@ prototypeAccessors.allowNewDotTarget.get = function() {
 };
 prototypeAccessors.allowUsing.get = function() {
   var ref2 = this.currentScope();
-  var flags = ref2.flags;
-  if (flags & SCOPE_SWITCH) {
+  var flags2 = ref2.flags;
+  if (flags2 & SCOPE_SWITCH) {
     return false;
   }
-  if (!this.inModule && flags & SCOPE_TOP) {
+  if (!this.inModule && flags2 & SCOPE_TOP) {
     return false;
   }
   return true;
@@ -11111,14 +11114,14 @@ pp$4.curPosition = function() {
   }
 };
 var pp$3 = Parser.prototype;
-var Scope = function Scope2(flags) {
-  this.flags = flags;
+var Scope = function Scope2(flags2) {
+  this.flags = flags2;
   this.var = [];
   this.lexical = [];
   this.functions = [];
 };
-pp$3.enterScope = function(flags) {
-  this.scopeStack.push(new Scope(flags));
+pp$3.enterScope = function(flags2) {
+  this.scopeStack.push(new Scope(flags2));
 };
 pp$3.exitScope = function() {
   this.scopeStack.pop();
@@ -11334,12 +11337,12 @@ var RegExpValidationState = function RegExpValidationState2(parser) {
   this.backReferenceNames = [];
   this.branchID = null;
 };
-RegExpValidationState.prototype.reset = function reset(start, pattern, flags) {
-  var unicodeSets = flags.indexOf("v") !== -1;
-  var unicode = flags.indexOf("u") !== -1;
+RegExpValidationState.prototype.reset = function reset(start, pattern, flags2) {
+  var unicodeSets = flags2.indexOf("v") !== -1;
+  var unicode = flags2.indexOf("u") !== -1;
   this.start = start | 0;
   this.source = pattern + "";
-  this.flags = flags;
+  this.flags = flags2;
   if (unicodeSets && this.parser.options.ecmaVersion >= 15) {
     this.switchU = true;
     this.switchV = true;
@@ -11416,15 +11419,15 @@ RegExpValidationState.prototype.eatChars = function eatChars(chs, forceU) {
 };
 pp$1.validateRegExpFlags = function(state) {
   var validFlags = state.validFlags;
-  var flags = state.flags;
+  var flags2 = state.flags;
   var u = false;
   var v = false;
-  for (var i2 = 0; i2 < flags.length; i2++) {
-    var flag = flags.charAt(i2);
+  for (var i2 = 0; i2 < flags2.length; i2++) {
+    var flag = flags2.charAt(i2);
     if (validFlags.indexOf(flag) === -1) {
       this.raise(state.start, "Invalid regular expression flag");
     }
-    if (flags.indexOf(flag, i2 + 1) > -1) {
+    if (flags2.indexOf(flag, i2 + 1) > -1) {
       this.raise(state.start, "Duplicate regular expression flag");
     }
     if (flag === "u") {
@@ -13036,20 +13039,20 @@ pp.readRegexp = function() {
   var pattern = this.input.slice(start, this.pos);
   ++this.pos;
   var flagsStart = this.pos;
-  var flags = this.readWord1();
+  var flags2 = this.readWord1();
   if (this.containsEsc) {
     this.unexpected(flagsStart);
   }
   var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
-  state.reset(start, pattern, flags);
+  state.reset(start, pattern, flags2);
   this.validateRegExpFlags(state);
   this.validateRegExpPattern(state);
   var value = null;
   try {
-    value = new RegExp(pattern, flags);
+    value = new RegExp(pattern, flags2);
   } catch (e) {
   }
-  return this.finishToken(types$1.regexp, { pattern, flags, value });
+  return this.finishToken(types$1.regexp, { pattern, flags: flags2, value });
 };
 pp.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
   var allowSeparators = this.options.ecmaVersion >= 12 && len === void 0;
@@ -14575,6 +14578,36 @@ async function deleteDatabase(client, databaseId, force) {
 async function listTables(client, databaseId) {
   return (await tablesRequest(client, "GET", `${DATABASES}/${encodeURIComponent(databaseId)}/tables`)).data;
 }
+function tablePath(databaseId, tableId) {
+  const tables = `${DATABASES}/${encodeURIComponent(databaseId)}/tables`;
+  return tableId ? `${tables}/${encodeURIComponent(tableId)}` : tables;
+}
+async function createTable(client, databaseId, table) {
+  return (await tablesRequest(client, "POST", tablePath(databaseId), table)).data;
+}
+async function updateTable(client, databaseId, tableId, table) {
+  return (await tablesRequest(client, "PUT", tablePath(databaseId, tableId), table)).data;
+}
+async function deleteTable(client, databaseId, tableId, force) {
+  await tablesRequestVoid(client, "DELETE", `${tablePath(databaseId, tableId)}${force ? "?force=true" : ""}`);
+}
+async function addField(client, databaseId, tableId, field) {
+  return (await tablesRequest(client, "POST", `${tablePath(databaseId, tableId)}/fields`, field)).data;
+}
+async function updateField(client, databaseId, tableId, fieldId, field) {
+  return (await tablesRequest(
+    client,
+    "PUT",
+    `${tablePath(databaseId, tableId)}/fields/${encodeURIComponent(fieldId)}`,
+    field
+  )).data;
+}
+async function deleteField(client, databaseId, tableId, fieldId) {
+  await tablesRequestVoid(client, "DELETE", `${tablePath(databaseId, tableId)}/fields/${encodeURIComponent(fieldId)}`);
+}
+async function listViews(client, databaseId, tableId) {
+  return (await tablesRequest(client, "GET", `${tablePath(databaseId, tableId)}/views`)).data;
+}
 
 // src/config/credentials.ts
 import { chmod, mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
@@ -14791,8 +14824,26 @@ async function authenticatedClient(target) {
 }
 
 // src/project/db-dir.ts
-import { mkdir as mkdir5, readFile as readFile6, rm, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile6, rm, writeFile as writeFile6 } from "node:fs/promises";
 import path8 from "node:path";
+
+// src/project/lookup.ts
+function byIdOrName(items, reference, kind, describe2 = (item) => item.id) {
+  const byId = items.find((item) => item.id === reference);
+  if (byId) {
+    return byId;
+  }
+  const byName = items.filter((item) => item.name === reference);
+  if (byName.length > 1) {
+    throw new CliError(
+      `Several ${kind}s are named "${reference}".`,
+      `Pass the id of one: ${byName.map(describe2).join(", ")}`
+    );
+  }
+  return byName[0];
+}
+
+// src/project/db-dir.ts
 var DB_CONFIG_FILE_NAME = "softr-db.jsonc";
 var DB_CACHE_DIR_NAME = ".softr-db";
 var DATABASE_ID_ENV_VAR = "SOFTR_DATABASE_ID";
@@ -14841,8 +14892,31 @@ async function writeSchemaCache(dir, database, tables) {
   const cache = { database, tables, refreshedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await mkdir5(path8.dirname(cacheFile(dir)), { recursive: true });
   await writeFile6(cacheFile(dir), JSON.stringify(cache, null, 2) + "\n");
+  await pruneViewsCache(dir, new Set(tables.map((table) => table.id)));
   return cache;
 }
+function viewsDir(dir) {
+  return path8.join(dir, DB_CACHE_DIR_NAME, "views");
+}
+async function writeViewsCache(dir, tableId, views) {
+  const value = { tableId, views, refreshedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await mkdir5(viewsDir(dir), { recursive: true });
+  await writeFile6(path8.join(viewsDir(dir), `${tableId}.json`), JSON.stringify(value, null, 2) + "\n");
+}
+async function pruneViewsCache(dir, tableIds) {
+  let names;
+  try {
+    names = await readdir2(viewsDir(dir));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  await Promise.all(
+    names.filter((name) => name.endsWith(".json") && !tableIds.has(name.slice(0, -".json".length))).map((name) => rm(path8.join(viewsDir(dir), name), { force: true }))
+  );
+}
 async function refreshSchemaCache(client, dir, databaseId) {
   const [database, tables] = await Promise.all([getDatabase(client, databaseId), listTables(client, databaseId)]);
   return writeSchemaCache(dir, database, tables);
@@ -14903,25 +14977,19 @@ async function databaseDirFor(cwd, explicitDir, databaseId, dirName) {
   return { dir: sibling2, existing: false };
 }
 async function findReachableDatabase(client, reference) {
-  const reachable = await listDatabases(client);
-  const byId = reachable.find((database) => database.id === reference);
-  if (byId) {
-    return byId;
-  }
-  const byName = reachable.filter((database) => database.name === reference);
-  if (byName.length > 1) {
-    throw new CliError(
-      `Several databases are named "${reference}".`,
-      `Pass the id of one: ${byName.map((database) => `${database.id} (workspace ${database.workspaceId})`).join(", ")}`
-    );
-  }
-  if (!byName[0]) {
+  const database = byIdOrName(
+    await listDatabases(client),
+    reference,
+    "database",
+    (item) => `${item.id} (workspace ${item.workspaceId})`
+  );
+  if (!database) {
     throw new CliError(
       `The token reaches no database with the id or name "${reference}".`,
       '"softr db list" shows the ones it reaches.'
     );
   }
-  return byName[0];
+  return database;
 }
 async function bindDatabaseDir(client, cwd, reference, explicitDir) {
   const here = path8.resolve(cwd, explicitDir ?? ".");
@@ -14944,6 +15012,10 @@ async function bindDatabaseDir(client, cwd, reference, explicitDir) {
   return { databaseId: database.id, dir, wrote: !existing };
 }
 
+// src/commands/db/help.ts
+var DATABASE_ID_HELP = `the database id (default: $SOFTR_DATABASE_ID, else the one in ${DB_CONFIG_FILE_NAME})`;
+var DATABASE_DIR_HELP = `database directory, the one holding ${DB_CONFIG_FILE_NAME} (default: the current directory)`;
+
 // src/api/studio.ts
 async function resolveTokenOwner(client) {
   try {
@@ -15420,18 +15492,11 @@ Next: softr workflows add <TYPE> --dir ${path10.relative(cwd, dir) || "."} (see
 }
 
 // src/commands/db/databases.ts
-var DATABASE_ARGUMENT = `the database id (default: $SOFTR_DATABASE_ID, else the one in ${DB_CONFIG_FILE_NAME})`;
-var DIR_OPTION = `database directory, the one holding ${DB_CONFIG_FILE_NAME} (default: the current directory)`;
 function renderDatabases(databases) {
   if (!databases.length) {
     return "The token reaches no database. Create one with: softr db create <name>";
   }
-  const table = new import_cli_table3.default({
-    head: ["ID", "Name", "Workspace", "Tables"],
-    colWidths: [38, 34, 38, 8],
-    wordWrap: true,
-    style: { head: [], border: [], "padding-left": 1, "padding-right": 1 }
-  });
+  const table = new import_cli_table3.default(plainTable(["ID", "Name", "Workspace", "Tables"], [38, 34, 38, 8]));
   for (const database of databases) {
     table.push([database.id, database.name, database.workspaceId, String(database.tablesCount)]);
   }
@@ -15502,7 +15567,7 @@ Wrote ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}.` : "";
       );
     }
   );
-  db2.command("update").description("Change a database's name or description").argument("[databaseId]", DATABASE_ARGUMENT).option("--name <name>", "the new name").option("--description <text>", "the new description").option("--dir <path>", DIR_OPTION).action(
+  db2.command("update").description("Change a database's name or description").argument("[databaseId]", DATABASE_ID_HELP).option("--name <name>", "the new name").option("--description <text>", "the new description").option("--dir <path>", DATABASE_DIR_HELP).action(
     async (databaseId, opts, command) => {
       if (!opts.name && !opts.description) {
         throw new CliError("Nothing to change: pass --name, --description or both.");
@@ -15521,7 +15586,7 @@ Wrote ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}.` : "";
       emit(options, `Updated database ${database.name} (${database.id}).`, { database });
     }
   );
-  db2.command("delete").description("Delete a database; one that still has tables needs --force").argument("[databaseId]", DATABASE_ARGUMENT).option("--force", "also delete its tables and all their records").option("--dir <path>", DIR_OPTION).action(async (databaseId, opts, command) => {
+  db2.command("delete").description("Delete a database; one that still has tables needs --force").argument("[databaseId]", DATABASE_ID_HELP).option("--force", "also delete its tables and all their records").option("--dir <path>", DATABASE_DIR_HELP).action(async (databaseId, opts, command) => {
     const options = globalOptions(command);
     const target = await resolveDatabase(process.cwd(), databaseId, opts.dir);
     const client = await authenticatedClient(resolveTarget());
@@ -15538,8 +15603,343 @@ ${path11.join(relativeDir(process.cwd(), target.dir), DB_CONFIG_FILE_NAME)} stil
   });
 }
 
-// src/commands/integrations.ts
+// src/commands/db/schema.ts
 var import_cli_table32 = __toESM(require_cli_table3(), 1);
+
+// src/commands/db/json-input.ts
+import { readFile as readFile8 } from "node:fs/promises";
+async function readJsonArgument(value, option, hint) {
+  let text = value;
+  if (value === "-") {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    text = Buffer.concat(chunks).toString("utf8");
+  } else if (value.startsWith("@")) {
+    text = await readFile8(value.slice(1), "utf8");
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(`${option} is not valid JSON.`, hint ?? "Pass inline JSON, @<file> or - for stdin.");
+  }
+}
+
+// src/commands/db/schema.ts
+var FIELD_REFERENCE_URL = "https://docs.softr.io/softr-api/softr-database-api/table-fields/add-table-field";
+var TABLE_ARGUMENT = "the table id or exact name";
+var FIELD_ARGUMENT = "the field id or exact name";
+function withDatabaseOptions(command) {
+  return command.option("--database <id>", DATABASE_ID_HELP).option("--dir <path>", DATABASE_DIR_HELP);
+}
+async function schemaContext(opts) {
+  const target = await resolveDatabase(process.cwd(), opts.database, opts.dir);
+  const client = await authenticatedClient(resolveTarget());
+  const cache = target.dir ? await readSchemaCache(target.dir) : void 0;
+  return { client, databaseId: target.databaseId, dir: target.dir, cache };
+}
+async function currentTables(context, fresh) {
+  if (!context.dir) {
+    return listTables(context.client, context.databaseId);
+  }
+  if (!fresh && context.cache) {
+    return context.cache.tables;
+  }
+  context.cache = await refreshSchemaCache(context.client, context.dir, context.databaseId);
+  return context.cache.tables;
+}
+function tableIn(context, tables, reference) {
+  const table = byIdOrName(tables, reference, "table");
+  if (!table) {
+    throw new CliError(
+      `Database ${context.databaseId} has no table with the id or name "${reference}".`,
+      '"softr db tables list" shows its tables.'
+    );
+  }
+  return table;
+}
+async function findTableOnServer(context, reference) {
+  return tableIn(context, await currentTables(context, true), reference);
+}
+async function findTableCached(context, reference) {
+  const cached = context.dir && context.cache ? byIdOrName(context.cache.tables, reference, "table") : void 0;
+  return cached ?? findTableOnServer(context, reference);
+}
+async function findField(context, tableReference, reference) {
+  const table = await findTableOnServer(context, tableReference);
+  const field = byIdOrName(table.fields, reference, "field");
+  if (!field) {
+    throw new CliError(
+      `Table ${table.name} has no field with the id or name "${reference}".`,
+      `"softr db tables get ${table.id}" shows its fields.`
+    );
+  }
+  return { table, field };
+}
+async function afterSchemaWrite(context) {
+  if (context.dir) {
+    context.cache = await refreshSchemaCache(context.client, context.dir, context.databaseId);
+  }
+}
+function parseOptions(json) {
+  if (json === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    throw new CliError("--options is not valid JSON.", `The options of each field type: ${FIELD_REFERENCE_URL}`);
+  }
+}
+function parseFieldSpec(spec) {
+  const colon = spec.lastIndexOf(":");
+  const name = colon > 0 ? spec.slice(0, colon).trim() : "";
+  const type = colon > 0 ? spec.slice(colon + 1).trim().toUpperCase() : "";
+  if (!name || !type) {
+    throw new CliError(`--field "${spec}" must be <name>:<TYPE>, for example "Due date:DATE".`);
+  }
+  return { name, type };
+}
+function parseFieldList(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError(
+      "--fields must be a JSON array of fields.",
+      `For example: [{"name": "Stage", "type": "SELECT", "options": {...}}]`
+    );
+  }
+  return value.map((item, index) => {
+    const field = item;
+    if (!field || typeof field !== "object" || typeof field.name !== "string" || !field.name || typeof field.type !== "string" || !field.type) {
+      throw new CliError(`--fields item ${index + 1} needs a "name" and a "type".`);
+    }
+    return { ...field, name: field.name, type: field.type.toUpperCase() };
+  });
+}
+function renderTables(tables) {
+  if (!tables.length) {
+    return "The database has no tables. Create one with: softr db tables create <name>";
+  }
+  const table = new import_cli_table32.default(plainTable(["ID", "Name", "Fields", "Primary field"], [18, 34, 8, 30]));
+  for (const item of tables) {
+    const primary = item.fields.find((field) => field.id === item.primaryFieldId);
+    table.push([item.id, item.name, String(item.fields.length), primary?.name ?? item.primaryFieldId]);
+  }
+  return table.toString();
+}
+function flags(field, primaryFieldId) {
+  return [
+    field.id === primaryFieldId ? "primary" : "",
+    field.required ? "required" : "",
+    field.readonly ? "read-only" : "",
+    field.allowMultipleEntries ? "multiple" : ""
+  ].filter(Boolean).join(", ");
+}
+function renderTable(item) {
+  const fields = new import_cli_table32.default(plainTable(["ID", "Name", "Type", ""], [18, 30, 18, 30]));
+  for (const field of item.fields) {
+    fields.push([field.id, field.name, field.type, flags(field, item.primaryFieldId)]);
+  }
+  return [
+    `${item.name} (${item.id})`,
+    ...item.description ? [`  ${item.description}`] : [],
+    `  Default view: ${item.defaultViewId}`,
+    fields.toString()
+  ].join("\n");
+}
+function renderField(table, field) {
+  return [
+    `${field.name} (${field.id}) in ${table.name}`,
+    ...field.description ? [`  ${field.description}`] : [],
+    `  Type:    ${field.type}`,
+    ...flags(field, table.primaryFieldId) ? [`  Flags:   ${flags(field, table.primaryFieldId)}`] : [],
+    `  Options: ${JSON.stringify(field.options ?? null)}`
+  ].join("\n");
+}
+function renderViews(views) {
+  const table = new import_cli_table32.default(plainTable(["ID", "Name"], [18, 50]));
+  for (const view of views) {
+    table.push([view.id, view.name]);
+  }
+  return table.toString();
+}
+function registerTables(db2) {
+  const tables = db2.command("tables").description("The tables of a database, with their fields");
+  withDatabaseOptions(tables.command("list").description("List the tables of the database")).action(
+    async (opts, command) => {
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const items = await currentTables(context, true);
+      emit(options, renderTables(items), { databaseId: context.databaseId, tables: items });
+    }
+  );
+  withDatabaseOptions(
+    tables.command("get").description("Show a table with its fields").argument("<table>", TABLE_ARGUMENT)
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTableOnServer(context, reference);
+    emit(options, renderTable(table), { table });
+  });
+  withDatabaseOptions(
+    tables.command("create").description(
+      "Create a table with at least one field; the first one names a record unless --primary-field says otherwise"
+    ).argument("<name>", "the table name").option("--description <text>", "what the table holds").option(
+      "--field <name:TYPE>",
+      "a field of a type without options, repeatable",
+      (value, previous) => [...previous, value],
+      []
+    ).option(
+      "--fields <json>",
+      `fields as a JSON array of {name, type, options?, description?, allowMultipleEntries?}, @<file> or - for stdin; they follow the --field ones (types and options: ${FIELD_REFERENCE_URL})`
+    ).option("--primary-field <name>", "the field that names a record (default: the first field)")
+  ).action(
+    async (name, opts, command) => {
+      const options = globalOptions(command);
+      const fields = [
+        ...opts.field.map(parseFieldSpec),
+        ...opts.fields === void 0 ? [] : parseFieldList(await readJsonArgument(opts.fields, "--fields"))
+      ];
+      if (!fields.length) {
+        throw new CliError(
+          'A table needs at least one field: pass --field <name>:<TYPE>, for example --field "Name:SINGLE_LINE_TEXT", or --fields with a JSON array.',
+          "The first field names a record unless --primary-field names another."
+        );
+      }
+      if (opts.primaryField && !fields.some((field) => field.name === opts.primaryField)) {
+        throw new CliError(`--primary-field "${opts.primaryField}" is not one of the fields' names.`);
+      }
+      const context = await schemaContext(opts);
+      const table = await createTable(context.client, context.databaseId, {
+        name,
+        description: opts.description,
+        primaryFieldName: opts.primaryField ?? fields[0].name,
+        fields
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Created table ${table.name} (${table.id}) with ${table.fields.length} fields.`, { table });
+    }
+  );
+  withDatabaseOptions(
+    tables.command("update").description("Change a table's name or description").argument("<table>", TABLE_ARGUMENT).option("--name <name>", "the new name").option("--description <text>", "the new description")
+  ).action(
+    async (reference, opts, command) => {
+      if (!opts.name && opts.description === void 0) {
+        throw new CliError("Nothing to change: pass --name, --description or both.");
+      }
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const current2 = await findTableOnServer(context, reference);
+      const table = await updateTable(context.client, context.databaseId, current2.id, {
+        name: opts.name ?? current2.name,
+        description: opts.description ?? current2.description
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Updated table ${table.name} (${table.id}).`, { table });
+    }
+  );
+  withDatabaseOptions(
+    tables.command("delete").description("Delete a table; one that still has records needs --force").argument("<table>", TABLE_ARGUMENT).option("--force", "also delete all its records")
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTableOnServer(context, reference);
+    await deleteTable(context.client, context.databaseId, table.id, opts.force === true);
+    await afterSchemaWrite(context);
+    emit(options, `Deleted table ${table.name} (${table.id}).`, { deleted: table.id });
+  });
+}
+function registerFields(db2) {
+  const fields = db2.command("fields").description("The fields of a table");
+  withDatabaseOptions(
+    fields.command("get").description("Show a field with its options").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT)
+  ).action(async (tableReference, reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const { table, field } = await findField(context, tableReference, reference);
+    emit(options, renderField(table, field), { tableId: table.id, field });
+  });
+  withDatabaseOptions(
+    fields.command("add").description("Add a field to a table").argument("<table>", TABLE_ARGUMENT).argument("<name>", "the field name").requiredOption("--type <TYPE>", "the field type, for example SINGLE_LINE_TEXT, NUMBER, SELECT, LINKED_RECORD").option("--options <json>", `the type's options as JSON (${FIELD_REFERENCE_URL})`).option("--description <text>", "what the field holds").option("--multiple", "allow several values (SELECT, LINKED_RECORD, USER, ATTACHMENT)")
+  ).action(
+    async (tableReference, name, opts, command) => {
+      const options = globalOptions(command);
+      const fieldOptions = parseOptions(opts.options);
+      const context = await schemaContext(opts);
+      const table = await findTableCached(context, tableReference);
+      const field = await addField(context.client, context.databaseId, table.id, {
+        name,
+        type: opts.type.toUpperCase(),
+        description: opts.description,
+        ...fieldOptions === void 0 ? {} : { options: fieldOptions },
+        allowMultipleEntries: opts.multiple === true
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Added field ${field.name} (${field.id}, ${field.type}) to ${table.name}.`, {
+        tableId: table.id,
+        field
+      });
+    }
+  );
+  withDatabaseOptions(
+    fields.command("update").description("Change a field: what is not passed stays as it is").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT).option("--name <name>", "the new name").option("--type <TYPE>", "the new type").option("--options <json>", `the new options as JSON, replacing the current ones (${FIELD_REFERENCE_URL})`).option("--description <text>", "the new description").option("--multiple", "allow several values").option("--no-multiple", "allow one value only")
+  ).action(
+    async (tableReference, reference, opts, command) => {
+      const fieldOptions = parseOptions(opts.options);
+      if (!opts.name && !opts.type && fieldOptions === void 0 && opts.description === void 0 && opts.multiple === void 0) {
+        throw new CliError("Nothing to change: pass --name, --type, --options, --description or --[no-]multiple.");
+      }
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const { table, field: current2 } = await findField(context, tableReference, reference);
+      const field = await updateField(context.client, context.databaseId, table.id, current2.id, {
+        name: opts.name ?? current2.name,
+        type: opts.type?.toUpperCase() ?? current2.type,
+        description: opts.description ?? current2.description,
+        options: fieldOptions ?? current2.options,
+        aiOptions: current2.aiOptions ?? null,
+        defaultValue: current2.defaultValue ?? null,
+        allowMultipleEntries: opts.multiple ?? current2.allowMultipleEntries
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Updated field ${field.name} (${field.id}, ${field.type}) in ${table.name}.`, {
+        tableId: table.id,
+        field
+      });
+    }
+  );
+  withDatabaseOptions(
+    fields.command("delete").description("Delete a field and its values in every record").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT)
+  ).action(async (tableReference, reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const { table, field } = await findField(context, tableReference, reference);
+    await deleteField(context.client, context.databaseId, table.id, field.id);
+    await afterSchemaWrite(context);
+    emit(options, `Deleted field ${field.name} (${field.id}) from ${table.name}.`, {
+      tableId: table.id,
+      deleted: field.id
+    });
+  });
+}
+function registerViews(db2) {
+  const views = db2.command("views").description("The views of a table");
+  withDatabaseOptions(
+    views.command("list").description("List the views of a table").argument("<table>", TABLE_ARGUMENT)
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTableOnServer(context, reference);
+    const items = await listViews(context.client, context.databaseId, table.id);
+    if (context.dir) {
+      await writeViewsCache(context.dir, table.id, items);
+    }
+    emit(options, renderViews(items), { tableId: table.id, views: items });
+  });
+}
+
+// src/commands/integrations.ts
+var import_cli_table33 = __toESM(require_cli_table3(), 1);
 import path12 from "node:path";
 function toRow(integration) {
   return {
@@ -15558,7 +15958,7 @@ function renderIntegrations(rows) {
   if (!rows.length) {
     return "No integrations connected in this workspace. Connect one in the studio (Workspace settings > Integrations).";
   }
-  const table = new import_cli_table32.default({
+  const table = new import_cli_table33.default({
     head: ["ID", "Name", "Type", "Account", "Auth"],
     colWidths: [38, 34, 22, 30, 11],
     wordWrap: true,
@@ -15610,7 +16010,7 @@ ${renderIntegrations(rows)}`, {
 }
 
 // src/commands/list.ts
-var import_cli_table33 = __toESM(require_cli_table3(), 1);
+var import_cli_table34 = __toESM(require_cli_table3(), 1);
 function toRow2(workflow, workspace) {
   return {
     id: workflow.id,
@@ -15652,7 +16052,7 @@ async function collectWorkflows(client, { workspaceId, applicationId } = {}) {
 }
 var TITLE_WIDTH = 34;
 function workflowTable(rows) {
-  const table = new import_cli_table33.default({
+  const table = new import_cli_table34.default({
     head: ["ID", "Title", "Triggers", "Status", "Version", "Draft"],
     // Only the free-text title wraps; the other columns size to their content, so trigger types are never cut off.
     colWidths: [null, TITLE_WIDTH, null, null, null, null],
@@ -15973,7 +16373,7 @@ ${identity.statements.map((s) => `  ${s.actions.join(", ")} on ${s.resources.joi
 }
 
 // src/commands/outputs.ts
-var import_cli_table35 = __toESM(require_cli_table3(), 1);
+var import_cli_table36 = __toESM(require_cli_table3(), 1);
 
 // src/project/test-state.ts
 function outdatedReferences(row) {
@@ -16022,7 +16422,7 @@ function collectVariables(nodeId, sample, metadata) {
 }
 
 // src/commands/test.ts
-var import_cli_table34 = __toESM(require_cli_table3(), 1);
+var import_cli_table35 = __toESM(require_cli_table3(), 1);
 var OUTPUTS_FILE = "outputs.json";
 function fieldCount(row) {
   const output = row.sampleOutput?.result?.output;
@@ -16123,7 +16523,7 @@ var LABEL = {
   error: "ERROR"
 };
 function renderResults(results) {
-  const table = new import_cli_table34.default({
+  const table = new import_cli_table35.default({
     head: ["Result", "Node", "Type", "Detail"],
     colWidths: [9, 30, 24, 60],
     wordWrap: true,
@@ -16239,7 +16639,7 @@ function sampleState(row) {
   }
 }
 function renderVariables(nodeId, entries, unverified) {
-  const table = new import_cli_table35.default({
+  const table = new import_cli_table36.default({
     head: ["Variable", "Type", "Example"],
     colWidths: [64, 32, 44],
     wordWrap: true,
@@ -16307,7 +16707,7 @@ function registerOutputs(program3) {
         outdated: Object.keys(outdatedReferences(row))
       };
     });
-    const table = new import_cli_table35.default({
+    const table = new import_cli_table36.default({
       head: ["Node", "Type", "Sample", "Fields"],
       colWidths: [30, 24, 60, 8],
       wordWrap: true,
@@ -16876,10 +17276,10 @@ ${unbacked.map(
 }
 
 // src/commands/spec.ts
-var import_cli_table36 = __toESM(require_cli_table3(), 1);
+var import_cli_table37 = __toESM(require_cli_table3(), 1);
 var TABLE_STYLE2 = { head: [], border: [], "padding-left": 1, "padding-right": 1 };
 function renderList() {
-  const table = new import_cli_table36.default({
+  const table = new import_cli_table37.default({
     head: ["Type", "Kind", "Label", "Summary"],
     colWidths: [40, 9, 24, 70],
     wordWrap: true,
@@ -16907,7 +17307,7 @@ function renderEntry(entry) {
   const blocks = [`${entry.type} (${entry.kind}) \u2014 ${entry.label}`, entry.summary, `Docs: ${entry.docs}`];
   const inputs = Object.entries(entry.inputs);
   if (inputs.length) {
-    const table = new import_cli_table36.default({
+    const table = new import_cli_table37.default({
       head: ["Input", "Type", "Required", "Description"],
       colWidths: [20, 9, 10, 90],
       wordWrap: true,
@@ -17157,14 +17557,14 @@ ${item.lines.map((line) => `       ${line}`).join("\n")}`
 }
 
 // src/commands/workspaces.ts
-var import_cli_table37 = __toESM(require_cli_table3(), 1);
+var import_cli_table38 = __toESM(require_cli_table3(), 1);
 function registerWorkspaces(program3) {
   program3.command("workspaces").description("The workspaces the stored token reaches, with your role and the scopes the token grants in each").action(async (_opts, command) => {
     const options = globalOptions(command);
     const target = resolveTarget();
     const client = await authenticatedClient(target);
     const workspaces = await listWorkspaces(client);
-    const table = new import_cli_table37.default({
+    const table = new import_cli_table38.default({
       head: ["ID", "Name", "Role", "Default", "Scopes"],
       colWidths: [38, 26, 10, 9, 34],
       wordWrap: true,
@@ -17191,7 +17591,7 @@ Pass --workspace <id> to a command, or set SOFTR_WORKSPACE_ID, to work in one of
 // package.json
 var package_default = {
   name: "@softr/cli",
-  version: "0.1.4",
+  version: "0.1.5",
   description: "The Softr command line: build, test and publish Softr workflows from local files, manage Softr Databases; more Softr APIs to come",
   keywords: [
     "softr",
@@ -17219,7 +17619,7 @@ var package_default = {
     format: "prettier --write .",
     "format:check": "prettier --check .",
     check: "npm run typecheck && npm run format:check && npm test && npm run build",
-    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows"
+    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows && npx -y skills-ref@0.1.5 validate skills/softr-db"
   },
   publishConfig: {
     access: "public"
@@ -17264,4 +17664,7 @@ registerSpec(workflows);
 registerSchema(workflows);
 var db = program2.command("db").description("Manage Softr Databases: databases, their tables, fields and records");
 registerDatabases(db);
+registerTables(db);
+registerFields(db);
+registerViews(db);
 program2.parseAsync(process.argv).catch(reportError);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softr/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "The Softr command line: build, test and publish Softr workflows from local files, manage Softr Databases; more Softr APIs to come",
   "keywords": [
     "softr",
@@ -28,7 +28,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "check": "npm run typecheck && npm run format:check && npm test && npm run build",
-    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows"
+    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows && npx -y skills-ref@0.1.5 validate skills/softr-db"
   },
   "publishConfig": {
     "access": "public"