dobo 2.0.0 → 2.2.0

package/wiki/APPLETS.md

@@ -0,0 +1,57 @@
+# Applet
+
+## connection
+
+Gunakan applet ini untuk menampilkan koneksi database yang Anda miliki
+
+```bash
+$ node index.js -a dobo:connection                        # Masuk ke mode interaktif
+$ node index.js -a dobo:connection default                # Tampilkan koneksi dengan nama 'default'
+$ node index.js -a dobo:connection default --format=json  # Tampilkan dalam format 'json'
+```
+
+## modelClear
+
+Hapus tabel yang Anda inginkan. **Perhatian**: tabel akan dihapus dari database BESERTA isinya. Jadi pastikan bahwa Anda telah membackup tabel Anda terlebih dahulu sebelum Anda memanggil applet ini.
+
+```bash
+$ node index.js -a dobo:modelRebuild                      # Masuk ke mode interaktif
+$ node index.js -a dobo:modelRebuild 'Cdb*'               # Hapus model dengan awalan 'Cdb'
+```
+
+## modelRebuild
+
+Pada saat pertama kali sebuah plugin dimuat dan plugin meng-extend Dobo, Anda perlu memanggil applet ini untuk membuat tabel sesuai dengan skema yang telah ditentukan.
+
+```bash
+$ node index.js -a dobo:modelRebuild                      # Gunakan mode interaktif
+$ node index.js -a dobo:modelRebuild CdbCountry Sumba     # Masukkan satu persatu nama modelnya
+$ node index.js -a dobo:modelRebuild 'Cdb*'               # List semua model dengan awalan 'Cdb'
+```
+Setelah tabel sukses dibuat, maka jika model dilengkapi dengan fixture, fixture tersebut akan dimuat didalam tabel yang bersangkutan.
+
+Jika tabel telah ada di database, Anda harus menggunakan switch ```--force``` untuk memaksa model bisa di hapus kemudian dibuat ulang kembali.
+
+## recordCreate
+
+Gunakan applet ini untuk membuat rekord:
+
+```bash
+$ node index.js -a dobo:recordCreate CdbCountry
+ℹ App is running as applet...
+✔ Enter JSON payload: { "id": "XX", "name": "My Country" }
+╭ CdbCountry ─────────────╮
+│ {                       │
+│   "id": "XX",           │
+│   "name": "My Country"  │
+│ }                       │
+╰─────────────────────────╯
+? Are you sure to continue? (y/N)
+```
+
+## recordFind
+
+Mencari rekord yang sesuai dengan kriteria pemilihan Anda. Jika kriteria tidak dimasukkan (filter kosong), maka akan diberikan semua rekord yang ada.
+
+```bash
+

package/wiki/CHANGES.md

@@ -0,0 +1,46 @@
+# Changes
+
+## 2026-01-11
+
+- [2.2.0] Any driver that support memory DB can now declare itself as in-memory DB and be handled as such
+- [2.2.0] ```driver.init()``` is removed, and driver should solely use ```driver.createClient()``` instead
+- [2.2.0] Bug fixes
+
+## 2026-01-07
+
+- [2.2.0] Add ```immutable``` feature
+- [2.2.0] Lots of bug fixes
+
+## 2025-12-28
+
+- [2.2.0] Add ```calcAggregate()``` & ```calcHistogram()``` for array of data objects
+- [2.2.0] Implement ```createAggregate()``` & ```createHistogram()``` to the built-in memory database driver
+- [2.2.0] If no ```default``` connection found, all models automatically bound to ```memory``` connection
+
+## 2025-12-22
+
+- [2.2.0] Introduce Action class that enables you to work on models with chainable methods
+- [2.2.0] All base class definitions moved now to ```this.baseClass``` instead of ```this.lib```
+
+## 2025-12-16
+
+- [2.2.0] Upgrade mingo to 7.1.0
+
+## 2025-12-14
+
+- [2.2.0] Drop Model class, replace as Model class
+
+## 2025-12-10
+
+- [2.2.0] Rewrite the whole thing into class based modules: Connection, Driver, Feature, Model. Dobo will solely serve as DB Manager in the future
+
+## 2025-12-05
+- [2.2.0] Connection now saved in ```this.connections``` as ```Connection``` instance
+
+## 2025-12-03
+
+- [2.1.0] Upgrade joi to 18.0.2
+- [2.1.0] Upgrade mingo to 7.0.2
+- [2.1.0] Feature now saved in ```this.features``` as ```Feature``` instance
+- [2.1.0] Driver now saved in ```this.drivers``` as ```Driver``` instance
+- [2.1.0] Add ```this.getDriver()```. Accept short name or NsPath format

package/wiki/CONFIG.md

@@ -0,0 +1,25 @@
+# Config Object
+
+| Key Name | Type | Default | Description |
+| ------- | ---- | ----- | ----------- |
+| ```connections``` | ```array``` | ```[]``` | Connection object |
+| ```validationParams``` | ```object``` | | Defaults to [Joi validate's](https://joi.dev/api/?v=17.13.3#anyvalidateasyncvalue-options) options |
+|     ```abortEarly``` | ```boolean``` | ```false``` | |
+|     ```convert``` | ```boolean``` | ```false``` | |
+|     ```allowUnknown``` | ```boolean``` | ```true``` | |
+| ```default``` | ```object``` | | default values |
+|     ```property``` | ```object``` | | |
+|         ```text``` | ```object``` | | |
+|             ```textType``` | ```string``` | ```text``` | Allowed values: ```text```, ```mediumtext```, or ```longtext``` |
+|         ```string``` | ```object``` | | |
+|             ```length``` | ```number``` | ```50``` | |
+|         ```filter``` | ```object``` | | |
+|             ```limit``` | ```number``` | ```25``` | Rows returned in one page |
+|             ```maxLimit``` | ```number``` | ```200``` | Max rows returned in one page |
+|             ```hardLimit``` | ```number``` | ```10000``` | Max rows returned on dataset export |
+|             ```sort``` | ```array``` | | |
+|         ```idField``` | ```object``` | | |
+| ```memDb``` | ```object``` | | |
+|     ```createDefConnAtStart``` | ```boolean``` | ```true``` | |
+|     ```persistence``` | ```object``` | | |
+|         ```syncPeriodDur``` | ```string | number``` | ```1s``` | |

package/wiki/CONTRIBUTING.md

@@ -0,0 +1,5 @@
+# Contributing
+
+Thanks very much to everyone who wants to join as a contributor, but I have committed to devoting 100% of my time to this project. Therefore, I'm currently unable to accept pull requests from anyone until the project is large enough for me to manage it independently.
+
+However, I am available if you encounter any bugs that require immediate fixes. Please report your issues in a GitHub issue, and I'll try to address them promptly. I'm also open to criticism and suggestions for improvements or requests for new features.

package/wiki/DEV-GUIDE.md

@@ -0,0 +1 @@
+# Developer Guide

package/wiki/ECOSYSTEM.md

@@ -0,0 +1,20 @@
+# Ecosystem
+
+## Drivers
+
+| Package | Docs | NS | Alias | Description |
+| ------- | ---- | -- | ----- | ----------- |
+| [dobo-couchdb](https://github.com/ardhi/dobo-couchdb) | [Docs](https://ardhi.github.io/dobo-couchdb) | doboCouchdb | dbcouch | CouchDB Driver |
+| [dobo-elasticsearch](https://github.com/ardhi/dobo-elasticsearch) | [Docs](https://ardhi.github.io/dobo-elasticsearch) | doboElasticsearch | dbes | Elasticsearch Driver |
+| [dobo-knex](https://github.com/ardhi/dobo-knex) | [Docs](https://ardhi.github.io/dobo-knex) | doboKnex | dbknex | Knex/SQL Driver |
+| [dobo-mongodb](https://github.com/ardhi/dobo-mongodb) | [Docs](https://ardhi.github.io/dobo-mongodb) | doboMongodb | dbmongo | MongoDB Driver |
+| [dobo-redis](https://github.com/ardhi/dobo-redis) | [Docs](https://ardhi.github.io/dobo-redis) | doboRedis | dbredis | Redis Driver |
+| [dobo-restproxy](https://github.com/ardhi/dobo-restproxy) | [Docs](https://ardhi.github.io/dobo-restproxy) | doboRestproxy | dbrpx | Restproxy Driver |
+| [dobo-restproxy-jsonserver](https://github.com/ardhi/dobo-restproxy-jsonserver) | [Docs](https://ardhi.github.io/dobo-restproxy-jsonserver) | doboResporoxyJsonserver | dbrpxjs |JsonServer Support for doboRestproxy |
+| [dobo-restproxy-ndut](https://github.com/ardhi/dobo-restproxy-ndut) | [Docs](https://ardhi.github.io/dobo-restproxy-ndut) | doboRestproxyNdut | dbrpxndut | NDUT Support for doboRestproxy |
+
+## Misc
+
+| Package | Docs | NS | Alias | Description |
+| ------- | ---- | -- | ----- | ----------- |
+| [dobo-extra](https://github.com/ardhi/dobo-extra) | [Docs](https://ardhi.github.io/dobo-extra) | doboExtra | dbx | Dobo Extra Tools/Utility |

package/wiki/GETTING-STARTED.md

@@ -0,0 +1,166 @@
+# Getting Started
+
+> If you're new to the [Dobo DBMS](https://ardhi.github.io/dobo), we recommend you to read and follow along with [Bajo Tutorial](https://ardhi.github.io/bajo/tutorial-01-getting-started.html) first, as this document is the continuation of it
+
+**Dobo** is the Bajo sub-framework developed specifically to handle database management. In this tutorial, we'll go over how to install the necessary packages and interact with them.
+
+Here is some basic knowledge about Dobo you need to be familiar with:
+
+- All record-related actions mimic REST API methods: *find* records, *get* a particular record by its ID, *create* a new record, *update* an existing record by ID and payload, and *remove* an existing record by its ID.
+- A Dobo model requires a predefined model. Even if you use a NoSQL database, you still need to write a model.
+- There are two main groups of methods to be familiar with:
+  - ```dobo.model{Action}``` methods manage everything related to model management, such as table creation or deletion.
+  - ```dobo.record{Action}``` methods handle record manipulation.
+- A record in Bajo always needs to have an ID. The ID can be alphanumeric characters or an integer, and it is defined by the underlying driver used by the model.
+
+For more info about Dobo, please [click here](https://ardhi.github.io/dobo).
+
+### Installation
+
+As you might have guessed, Dobo and its drivers are normal Bajo plugins. Although [many drivers](https://github.com/ardhi/dobo/tutorials/drivers.md) exist, for this tutorial, we'll only use SQLite 3, which is provided by the dobo-knex driver.
+
+Now, please install the required plugins and SQLite drivers first:
+
+```bash
+$ npm install dobo dobo-knex sqlite3
+```
+
+Don't forget to add ```dobo``` and ```dobo-knex``` to the ```data/config/.plugins``` file.
+
+### Model
+
+Let's pretend we're building an address book with fields like name, age, phone, etc. This entity needs to be modeled with a model and then "connected" to a database:
+
+1. Create ```main/extend/dobo/model/address-book.json``` file.
+2. Enter the following model:
+   ```json
+   {
+     "properties": [{
+       "name": "firstName",
+       "type": "string",
+       "maxLength": 20,
+       "required": true,
+       "index": true
+     },
+       "lastName::20:true:true",
+       "age:smallint",
+       "phone::20:true:true",
+       "email::50:true"
+     ],
+     "feature": {
+       "createdAt": true,
+       "updatedAt": true
+     }
+   }
+   ```
+   You should notice here that in properties you can use either the verbose, full-object syntax or the string-based one. Please visit the Dobo documentation to learn more.
+
+3. Create ```main/extend/dobo/fixture/address-book.json``` file. Fixtures allow you to quickly fill your database with predefined records. It's not required, but it helps a lot with prototyping.
+   ```json
+   [{
+     "firstName": "James",
+     "lastName": "Bond",
+     "phone": "+44-007"
+   }, {
+     "firstName": "Felix",
+     "lastName": "Leiter",
+     "age": 50,
+     "phone": "+1-0000001"
+   }]
+   ```
+4. By default, all models are connected to a database connection named ```default```. Now let's create this connection by creating ```data/config/dobo.json``` file:
+
+   ```json
+   {
+     "connections": [{
+       "name": "default",
+       "type": "knex:sqlite3",
+       "connection": {
+         "filename": "my-project.sqlite3"
+       }
+     }]
+   }
+   ```
+5. That's all there is to it. Now you need to build this model like this:
+   ```
+   $ node index.js -a dobo:modelRebuild MainAddressBook
+   ℹ App runs in applet mode
+   ╭ Model (1) ──────╮
+   │ MainAddressBook  │
+   ╰──────────────────╯
+   ✔ The above mentioned model(s) will be rebuilt as model. Continue? Yes
+   ✔ Model 'MainAddressBook' successfully created
+   ℹ Done! Succeded: 1, failed: 0, skipped: 0
+   ✔ Fixture on 'MainAddressBook': added 2, rejected: 0
+   ```
+6. Done!
+
+Note: Although you can use YAML or TOML for models/fixtures, it's recommended to stick with JSON because it's always supported and doesn't require an extra plugin.
+
+Dobo models are by default always named with ```{Alias}{ModelName}```, which is a pascal-cased plugin alias and base name from your model file. For field names, Dobo use camel-cased names as a convention. You can change this behavior to match your needs, but it is suggested that you're keeping these conventions at least for this tutorial.
+
+### Applets
+
+Dobo provides you with a number of applets that will help you manipulate models and records directly. This means you don't have to touch your tables and databases directly through SQL statements or NoSQL procedures ever again. Everything can be managed through one common syntax provided by Dobo, regardless of your backend type.
+
+First, let's try to list records:
+
+```bash
+$ node index.js -a dobo:recordFind MainAddressBook
+ℹ App runs in applet mode
+✔ Please enter your query (if any):
+✔ Done
+┌────┬───────────┬──────────┬─────┬────────────┬───────┬──────────────────────────┬──────────────────────────┐
+│ id │ firstName │ lastName │ age │ phone      │ email │ createdAt                │ updatedAt                │
+├────┼───────────┼──────────┼─────┼────────────┼───────┼──────────────────────────┼──────────────────────────┤
+│ 2  │ Felix     │ Leiter   │ 50  │ +1-0000001 │       │ 2025-09-18T13:47:29.296Z │ 2025-09-18T13:47:29.296Z │
+├────┼───────────┼──────────┼─────┼────────────┼───────┼──────────────────────────┼──────────────────────────┤
+│ 1  │ James     │ Bond     │     │ +44-007    │       │ 2025-09-18T13:47:29.280Z │ 2025-09-18T13:47:29.280Z │
+└────┴───────────┴──────────┴─────┴────────────┴───────┴──────────────────────────┴──────────────────────────┘
+```
+
+Now, add a new record:
+
+```bash
+$ node index.js -a dobo:recordCreate MainAddressBook
+ℹ App runs in applet mode
+✔ Enter JSON payload: { "firstName": "Miss", "lastName": "Moneypenny" }
+╭ MainAddressBook ────────────╮
+│ {                           │
+│   "firstName": "Miss",      │
+│   "lastName": "Moneypenny"  │
+│ }                           │
+╰─────────────────────────────╯
+✖ Error: Validation Error
+✔ Enter JSON payload: { "firstName": "Miss", "lastName": "Moneypenny", "phone": "+44-111" }
+╭ MainAddressBook ─────────────╮
+│ {                            │
+│   "firstName": "Miss",       │
+│   "lastName": "Moneypenny",  │
+│   "phone": "+44-111"         │
+│ }                            │
+╰──────────────────────────────╯
+✔ Done
+┌───────────┬──────────────────────────┐
+│ id        │ 3                        │
+├───────────┼──────────────────────────┤
+│ firstName │ Miss                     │
+├───────────┼──────────────────────────┤
+│ lastName  │ Moneypenny               │
+├───────────┼──────────────────────────┤
+│ age       │                          │
+├───────────┼──────────────────────────┤
+│ phone     │ +44-111                  │
+├───────────┼──────────────────────────┤
+│ email     │                          │
+├───────────┼──────────────────────────┤
+│ createdAt │ 2025-09-18T14:38:11.933Z │
+├───────────┼──────────────────────────┤
+│ updatedAt │ 2025-09-18T14:38:11.933Z │
+└───────────┴──────────────────────────┘
+```
+
+As you can see, Dobo is smart enough to reject any payload that isn't right. In this case, we forgot to include the phone number since according to the model, this field is defined as required.
+
+You can now try all of Dobo's other applets. [This page](https://github.com/ardhi/dobo/tutorials/applets) provides its complete list.
+

package/wiki/USER-GUIDE.md

@@ -0,0 +1 @@
+# User Guide

package/extend/bajoCli/applet/model-clear.js

@@ -1,11 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function modelClear (...args) {
-  const { print } = this.app.bajo
-  const { isEmpty } = this.lib._
-  if (isEmpty(this.schemas)) return print.fail('notFound%s', 'schema', { exit: this.app.bajo.applet })
-  const [schema] = args
-  await postProcess.call(this, { handler: 'modelClear', params: [schema], path: 'modelClear', processMsg: 'Clear records' })
-}
-
-export default modelClear

package/extend/bajoCli/applet/model-rebuild.js

@@ -1,101 +0,0 @@
-import addFixtures from '../../lib/add-fixtures.js'
-
-async function modelRebuild (...args) {
-  const { importPkg } = this.app.bajo
-  const { outmatch } = this.lib
-  const { isEmpty, map, trim, without } = this.lib._
-  const [input, confirm, boxen] = await importPkg('bajoCli:@inquirer/input',
-    'bajoCli:@inquirer/confirm', 'bajoCli:boxen')
-  const schemas = map(this.schemas, 'name')
-  let names = args.join(' ')
-  if (isEmpty(schemas)) return this.print.fail('notFound%s', 'schema', { exit: this.app.bajo.applet })
-  if (isEmpty(names)) {
-    names = await input({
-      message: this.print.write('enterSchemaName'),
-      default: '*'
-    })
-  }
-  const isMatch = outmatch(map(names.split(' '), m => trim(m)))
-  names = schemas.filter(isMatch)
-  if (names.length === 0) return this.print.fail('No schema matched', true, { exit: this.app.bajo.applet })
-  console.log(boxen(names.join(' '), { title: this.print.write('schema%d', names.length), padding: 0.5, borderStyle: 'round' }))
-  const answer = await confirm({
-    message: this.print.write('schemasWillBeRebuiltContinue'),
-    default: false
-  })
-  if (!answer) return this.print.fail('aborted', { exit: this.app.bajo.applet })
-  /*
-  const conns = []
-  for (const s of names) {
-    const { connection } = this.getInfo(s)
-    if (!conns.includes(connection.name)) conns.push(connection.name)
-  }
-  */
-  await this.start('all')
-  const result = { succed: 0, failed: 0, skipped: 0 }
-  const skipped = []
-  for (const s of names) {
-    const { schema, instance } = this.getInfo(s)
-    const spin = this.print.spinner({ showCounter: true }).start('rebuilding%s', schema.name)
-    if (!instance) {
-      spin.warn('clientInstanceNotConnected%s', schema.connection, schema.name)
-      skipped.push(schema.name)
-      result.skipped++
-      continue
-    }
-    /*
-    if (connection.memory) {
-      spin.warn('memoryDbSkipped%s', schema.name)
-      continue
-    }
-    */
-    const exists = await this.modelExists(schema.name, false, { spinner: spin })
-    if (exists) {
-      if (this.app.bajo.config.force) {
-        try {
-          await this.modelDrop(schema.name, { spinner: spin })
-          spin.setText('modelDropped%s', schema.name)
-        } catch (err) {
-          spin.fail('errorDroppingModel%s%s', schema.name, err.message)
-          result.failed++
-          continue
-        }
-      } else {
-        spin.fail('modelExistsNeedForce%s', schema.name)
-        result.failed++
-        continue
-      }
-    }
-    try {
-      await this.modelCreate(schema.name, { spinner: spin })
-      spin.succeed('modelCreated%s', schema.name)
-      result.succed++
-    } catch (err) {
-      if (this.app.bajo.config.log.applet && this.app.bajo.config.log.level === 'trace') console.error(err)
-      spin.fail('errorCreatingModel%s%s', schema.name, err.message)
-      result.failed++
-    }
-  }
-  this.print.info('succeedFailSkip%d%d%d', result.succed, result.failed, result.skipped)
-  if (result.failed > 0) this.print.fatal('cantContinueAddFixture')
-  for (const s of without(names, ...skipped)) {
-    const { schema, connection } = this.getInfo(s)
-    const spin = this.print.spinner({ showCounter: true }).start('addingFixture%s', schema.name)
-    if (connection.memory) {
-      spin.warn('memoryDbSkipped%s', schema.name)
-      continue
-    }
-    try {
-      const fixture = await addFixtures.call(this, schema.name, { spinner: spin })
-      spin.succeed('fixtureAdded%s%s%s', schema.name, fixture.success, fixture.failed)
-      result.succed++
-    } catch (err) {
-      if (this.app.bajo.config.log.applet && this.app.bajo.config.log.level === 'trace') console.error(err)
-      spin.fail('errorAddingFixture%s%s', schema.name, err.message)
-      result.failed++
-    }
-  }
-  process.exit()
-}
-
-export default modelRebuild

package/extend/bajoCli/applet/record-create.js

@@ -1,41 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function createRecord (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map, isPlainObject } = this.lib._
-  const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
-    'bajoCli:@inquirer/select', 'bajoCli:boxen')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, body] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('selectSchema'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(body)) {
-    body = await input({
-      message: this.print.write('enterJsonPayload'),
-      validate: text => {
-        if (isEmpty(text)) return this.print.write('payloadRequired')
-        try {
-          const parsed = JSON.parse(text)
-          if (!isPlainObject(parsed)) throw new Error()
-        } catch (err) {
-          return this.print.write('payloadMustBeJson')
-        }
-        return true
-      }
-    })
-  }
-  let payload
-  try {
-    payload = JSON.parse(body)
-  } catch (err) {
-    return this.print.fail('invalidPayloadSyntax', { exit: this.app.bajo.applet })
-  }
-  console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
-  await postProcess.call(this, { handler: 'recordCreate', params: [schema, payload], path, processMsg: 'Creating record' })
-}
-
-export default createRecord

package/extend/bajoCli/applet/record-find.js

@@ -1,27 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function findRecord (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map, pick } = this.lib._
-  const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, query] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('selectSchema'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(query)) {
-    query = await input({
-      message: this.print.write('enterQueryIfAny')
-    })
-  }
-  if (isEmpty(query)) query = {}
-  const filter = pick(this.app.bajo.config, ['page', 'offset', 'pageSize', 'sort', 'limit'])
-  filter.pageSize = filter.pageSize ?? filter.limit
-  filter.query = query
-  await postProcess.call(this, { noConfirmation: true, handler: 'recordFind', params: [schema, filter], path, processMsg: 'Finding record(s)' })
-}
-
-export default findRecord

package/extend/bajoCli/applet/record-get.js

@@ -1,24 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function getRecord (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map } = this.lib._
-  const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, id] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('Please select a schema:'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(id)) {
-    id = await input({
-      message: this.print.write('Enter record ID:'),
-      validate: text => isEmpty(text) ? this.print.write('ID is required') : true
-    })
-  }
-  await postProcess.call(this, { noConfirmation: true, handler: 'recordGet', params: [schema, id], path, processMsg: 'Getting record' })
-}
-
-export default getRecord

package/extend/bajoCli/applet/record-remove.js

@@ -1,24 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function removeRecord (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map } = this.lib._
-  const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, id] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('Please select a schema:'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(id)) {
-    id = await input({
-      message: this.print.write('Enter record ID:'),
-      validate: text => isEmpty(text) ? this.print.write('ID is required') : true
-    })
-  }
-  await postProcess.call(this, { handler: 'recordRemove', params: [schema, id], path, processMsg: 'Removing record' })
-}
-
-export default removeRecord

package/extend/bajoCli/applet/record-update.js

@@ -1,47 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function updateRecord (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map, isPlainObject } = this.lib._
-  const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
-    'bajoCli:@inquirer/select', 'bajoCli:boxen')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, id, body] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('selectSchema'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(id)) {
-    id = await input({
-      message: this.print.write('enterRecordId'),
-      validate: text => isEmpty(text) ? this.print.write('idIsRequired') : true
-    })
-  }
-  if (isEmpty(body)) {
-    body = await input({
-      message: this.print.write('enterJsonPayload'),
-      validate: text => {
-        if (isEmpty(text)) return this.print.write('payloadRequired')
-        try {
-          const parsed = JSON.parse(text)
-          if (!isPlainObject(parsed)) throw new Error()
-        } catch (err) {
-          return this.print.write('payloadMustBeJson')
-        }
-        return true
-      }
-    })
-  }
-  let payload
-  try {
-    payload = JSON.parse(body)
-  } catch (err) {
-    return this.print.fail('invalidPayloadSyntax', { exit: this.app.bajo.applet })
-  }
-  console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
-  await postProcess.call(this, { handler: 'recordUpdate', params: [schema, id, payload], path, processMsg: 'Updating record' })
-}
-
-export default updateRecord

package/extend/bajoCli/applet/schema.js

@@ -1,22 +0,0 @@
-async function schema (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map, find } = this.lib._
-  const { getOutputFormat, writeOutput } = this.app.bajoCli
-  const select = await importPkg('bajoCli:@inquirer/select')
-  const format = getOutputFormat()
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let name = args[0]
-  if (isEmpty(name)) {
-    const choices = map(this.schemas, s => ({ value: s.name }))
-    name = await select({
-      message: this.print.write('selectSchema'),
-      choices
-    })
-  }
-  const result = find(this.schemas, { name })
-  if (!result) return this.print.fail('cantFindSchema%s', this.print.write('schema'), name, { exit: this.app.bajo.applet })
-  this.print.info('done')
-  await writeOutput(result, path, format)
-}
-
-export default schema