@adobe/aio-cli-plugin-app-storage 1.1.0 → 1.2.0-pre.2025-11-18.sha-9c4079ac

package/src/commands/app/db/document/find.js

@@ -0,0 +1,133 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License")
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../../DBBaseCommand.js'
+import { Args, Flags } from '@oclif/core'
+import { asObject, isNonEmptyString } from '../../../../utils/inputValidation.js'
+import chalk from 'chalk'
+import { prettyJson } from '../../../../utils/output.js'
+
+export class Find extends DBBaseCommand {
+  async run () {
+    const { collection, filter } = this.args
+    const { limit, skip, sort, projection } = this.flags
+
+    try {
+      this.log(chalk.blue(`Finding documents in collection '${collection}'...`))
+      this.log(chalk.dim(`   Filter:\n${prettyJson(filter)}`))
+
+      // Prepare options for find
+      const options = { limit }
+      this.log(chalk.dim(`   Limit: ${limit}`))
+      if (skip !== undefined) {
+        this.log(chalk.dim(`   Skip: ${skip}`))
+        options.skip = skip
+      }
+      if (sort !== undefined) {
+        this.log(chalk.dim(`   Sort:\n${prettyJson(sort)}`))
+        options.sort = sort
+      }
+      if (projection !== undefined) {
+        this.log(chalk.dim(`   Projection:\n${prettyJson(projection)}`))
+        options.projection = projection
+      }
+
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}\n`))
+
+      const client = await this.db.connect()
+      const coll = client.collection(collection)
+      const results = await coll.findArray(filter, options)
+      const timestamp = new Date().toISOString()
+      const response = {
+        collection,
+        filter,
+        options,
+        results,
+        namespace: this.rtNamespace,
+        timestamp
+      }
+
+      this.debugLogger?.info?.('Find results:', results)
+      if (results?.length > 0) {
+        this.log(chalk.green(`Retrieved ${results.length} document(s) from collection '${collection}'`))
+        this.log(chalk.dim(`   Searched: ${timestamp}`))
+        this.log(chalk.dim(`   Results:\n${prettyJson(results)}`))
+      } else {
+        this.log(chalk.green(`No documents matching the filter criteria found in collection '${collection}'.`))
+        this.log(chalk.dim(`   Searched: ${timestamp}`))
+      }
+
+      return response
+    } catch (error) {
+      this.debugLogger?.error?.('Error finding documents:', error)
+
+      const errorMessage = `Failed to find documents in collection '${collection}': ${error.message}`
+
+      this.log(chalk.red('Failed to find documents'))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.error(errorMessage)
+    }
+  }
+}
+
+Find.description = 'Find documents in a collection based on filter criteria.'
+
+Find.examples = [
+  '$ aio app db document find users \'{}\'',
+  '$ aio app db document find products \'{"category": "Computer Accessories"}\' --json',
+  '$ aio app db document find products \'{"name": {"$regex": "Speakers$"}}\' --sort \'{"price": -1}\' --limit 10 --skip 5 --projection \'{"name": 1, "price": 1}\'',
+  '$ aio app db doc find orders \'{"status": "pending"}\' --sort \'{"orderDate": -1}\''
+]
+
+Find.args = {
+  collection: Args.string({
+    name: 'collection',
+    description: 'The name of the collection',
+    required: true,
+    parse: input => isNonEmptyString(input, 'Collection name')
+  }),
+  filter: Args.string({
+    name: 'filter',
+    description: 'Filter criteria for the documents to find (JSON string, e.g. \'{"status": "active"}\')',
+    required: true,
+    parse: input => asObject(input, 'Filter')
+  })
+}
+
+Find.flags = {
+  ...DBBaseCommand.flags,
+  limit: Flags.integer({
+    char: 'l',
+    description: 'Limit the number of documents returned, max: 100',
+    default: 20,
+    max: 100,
+    min: 0
+  }),
+  skip: Flags.integer({
+    char: 's',
+    description: 'Skip the first N documents',
+    min: 0
+  }),
+  sort: Flags.string({
+    char: 'o',
+    description: 'Sort specification as a JSON object (e.g. \'{"field": 1}\')',
+    parse: input => asObject(input, 'Sort')
+  }),
+  projection: Flags.string({
+    char: 'p',
+    description: 'Projection specification as a JSON object (e.g. \'{"field1": 1, "field2": 0}\')',
+    parse: input => asObject(input, 'Projection')
+  })
+}
+
+Find.aliases = ['app:db:doc:find']

package/src/commands/app/db/document/insert.js

@@ -0,0 +1,147 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../../DBBaseCommand.js'
+import { Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import { isNonEmptyString } from '../../../../utils/inputValidation.js'
+import { prettyJson } from '../../../../utils/output.js'
+
+export class Insert extends DBBaseCommand {
+  async run () {
+    const { collection, documents } = this.args
+    const { bypassDocumentValidation } = this.flags
+
+    try {
+      this.log(chalk.blue(`Inserting ${documents.length} documents into collection '${collection}'...`))
+
+      // Build options object
+      const insertOptions = {}
+      if (bypassDocumentValidation) {
+        insertOptions.bypassDocumentValidation = true
+        this.log(chalk.dim('   Bypassing document validation'))
+      }
+
+      const client = await this.db.connect()
+      const coll = await client.collection(collection)
+
+      // Perform the insert operation
+      const result = await coll.insertMany(documents, insertOptions)
+
+      this.debugLogger?.info?.('Documents inserted successfully:', result)
+
+      const response = {
+        collection,
+        status: 'inserted',
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString(),
+        result
+      }
+
+      if (bypassDocumentValidation) {
+        response.options = insertOptions
+      }
+
+      this.log(chalk.green(`Successfully inserted ${result.insertedCount} documents into collection '${collection}'`))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+
+      if (result.insertedIds && Object.keys(result.insertedIds).length > 0) {
+        this.log(chalk.dim(`   Inserted IDs: ${JSON.stringify(result.insertedIds)}`))
+      }
+
+      this.log(chalk.dim(`   Details:\n${prettyJson(result)}`))
+
+      this.log(chalk.dim(`   Inserted: ${new Date().toLocaleString()}`))
+
+      return response
+    } catch (error) {
+      this.debugLogger?.error?.('Error inserting documents:', error)
+
+      const errorMessage = `Failed to insert documents into collection '${collection}': ${error.message}`
+
+      this.log(chalk.red('Failed to insert documents'))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Error: ${error.message}`))
+
+      this.error(errorMessage)
+    }
+  }
+}
+
+Insert.description = 'Insert one or more documents into a collection'
+
+Insert.examples = [
+  '$ aio app db document insert users \'{"name": "John", "age": 30}\'',
+  '$ aio app db document insert products \'[{"id": 1, "name": "Product A"}, {"id": 2, "name": "Product B"}]\' --json',
+  '$ aio app db document insert temp \'{"data": "test"}\' --bypassDocumentValidation',
+  '$ aio app db doc insert bulk \'[{"field": "foo"}, {"field": "bar"}]\' --bypassDocumentValidation --json'
+]
+
+Insert.args = {
+  collection: Args.string({
+    name: 'collection',
+    description: 'The name of the collection to insert documents into',
+    required: true,
+    parse: input => isNonEmptyString(input, 'Collection name')
+  }),
+  documents: Args.string({
+    name: 'documents',
+    description: 'JSON object or array of documents to insert',
+    required: true,
+    parse: input => {
+      if (typeof input !== 'string' || input.trim().length === 0) {
+        throw new Error('Documents: Must be a JSON string representing an object or non-empty array')
+      }
+
+      let result
+      try {
+        result = JSON.parse(input)
+      } catch (e) {
+        throw new Error(`Documents: JSON parse error: ${e.message}`)
+      }
+
+      const isSingleDoc = !Array.isArray(result)
+      if (isSingleDoc) {
+        result = [result]
+      }
+
+      if (result.length === 0) {
+        throw new Error('Documents: Cannot be empty')
+      }
+
+      // Validate each document is an object
+      for (let i = 0; i < result.length; i++) {
+        if (typeof result[i] !== 'object' || result[i] === null || Array.isArray(result[i])) {
+          if (isSingleDoc) {
+            throw new Error('Documents: Must be a JSON string representing an object or non-empty array')
+          }
+          throw new Error(`Documents: Element at index ${i} must be an object`)
+        }
+      }
+
+      return result
+    }
+  })
+}
+
+Insert.flags = {
+  ...DBBaseCommand.flags,
+  bypassDocumentValidation: Flags.boolean({
+    char: 'b',
+    description: 'Bypass schema validation if present',
+    default: false
+  })
+}
+
+Insert.aliases = ['app:db:doc:insert']

package/src/commands/app/db/document/replace.js

@@ -0,0 +1,122 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../../DBBaseCommand.js'
+import { Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import { asObject, isNonEmptyString } from '../../../../utils/inputValidation.js'
+
+export class Replace extends DBBaseCommand {
+  async run () {
+    const { collection, filter, replacement } = this.args
+    const { upsert } = this.flags
+
+    try {
+      this.log(chalk.blue(`Replacing document in collection '${collection}'...`))
+
+      if (upsert) {
+        this.log(chalk.dim('   Upsert enabled: Will create document if not found'))
+      }
+
+      const client = await this.db.connect()
+      const coll = client.collection(collection)
+
+      // Build options
+      const options = {}
+      if (upsert) {
+        options.upsert = true
+      }
+
+      // Replace the document
+      const result = await coll.replaceOne(filter, replacement, options)
+
+      this.debugLogger?.info?.('Document replaced successfully:', result)
+
+      const response = {
+        collection,
+        filter,
+        replacement,
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString(),
+        result
+      }
+
+      if (result.matchedCount > 0) {
+        this.log(chalk.green(`Document replaced successfully in collection '${collection}'`))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      } else if (upsert && result.upsertedId) {
+        this.log(chalk.green(`Document created (upserted) in collection '${collection}'`))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+        this.log(chalk.dim(`   Upserted ID: ${result.upsertedId}`))
+        this.log(chalk.dim(`   Upserted count: ${result.upsertedCount}`))
+      } else {
+        this.log(chalk.yellow(`No document found in collection '${collection}' matching the filter`))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      }
+
+      this.log(chalk.dim(`   Replaced: ${new Date().toLocaleString()}`))
+
+      return response
+    } catch (error) {
+      this.debugLogger?.error?.('Error replacing document:', error)
+
+      const errorMessage = `Failed to replace document in collection '${collection}': ${error.message}`
+
+      this.log(chalk.red('Failed to replace document'))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+
+      this.error(errorMessage)
+    }
+  }
+}
+
+Replace.description = 'Replace a single document in a collection'
+
+Replace.examples = [
+  '$ aio app db document replace users \'{"name": "John"}\' \'{"name": "John Doe", "age": 30, "status": "active"}\'',
+  '$ aio app db document replace products \'{"id": "123"}\' \'{"id": "123", "name": "New Product", "price": 99.99}\' --json',
+  '$ aio app db document replace posts \'{"slug": "hello-world"}\' \'{"title": "Hello World", "content": "Updated content", "status": "published"}\' --upsert',
+  '$ aio app db doc replace users \'{"email": "john@example.com"}\' \'{"email": "john@example.com", "name": "John", "verified": true}\' --upsert --json'
+]
+
+Replace.args = {
+  collection: Args.string({
+    name: 'collection',
+    description: 'The name of the collection',
+    required: true,
+    parse: input => isNonEmptyString(input, 'Collection name')
+  }),
+  filter: Args.string({
+    name: 'filter',
+    description: 'The filter document (JSON string)',
+    required: true,
+    parse: input => asObject(input, 'Filter')
+  }),
+  replacement: Args.string({
+    name: 'replacement',
+    description: 'The replacement document (JSON string)',
+    required: true,
+    parse: input => asObject(input, 'Replacement')
+  })
+}
+
+Replace.flags = {
+  ...DBBaseCommand.flags,
+  upsert: Flags.boolean({
+    char: 'u',
+    description: 'If no document is found, create a new one',
+    default: false
+  })
+}
+
+Replace.aliases = ['app:db:doc:replace']

package/src/commands/app/db/document/update.js

@@ -0,0 +1,144 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../../DBBaseCommand.js'
+import { Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import { asObject, isNonEmptyString } from '../../../../utils/inputValidation.js'
+
+export class Update extends DBBaseCommand {
+  async run () {
+    const { collection, filter, update } = this.args
+    const { many, upsert } = this.flags
+    const docPlural = many ? '(s)' : ''
+
+    try {
+      this.log(chalk.blue(`Updating document${docPlural} in collection '${collection}'...`))
+      this.log(chalk.dim(`   Filter: ${JSON.stringify(filter)}`))
+      this.log(chalk.dim(`   Update: ${JSON.stringify(update)}`))
+
+      if (upsert) {
+        this.log(chalk.dim('   Upsert enabled: Will create document if not found'))
+      }
+
+      const client = await this.db.connect()
+      const coll = client.collection(collection)
+
+      // Build options
+      const options = {}
+      if (upsert) {
+        options.upsert = true
+      }
+
+      // Update the document
+      const result = await (many ? coll.updateMany(filter, update, options) : coll.updateOne(filter, update, options))
+
+      this.debugLogger?.info?.(`Document${docPlural} updated successfully:`, result)
+
+      const response = {
+        collection,
+        filter,
+        update,
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString(),
+        result
+      }
+      const optionOutput = { ...options }
+      if (many) {
+        optionOutput.many = true
+      }
+      if (Object.keys(optionOutput).length > 0) {
+        response.options = optionOutput
+      }
+
+      if (result.matchedCount > 0) {
+        if (result.modifiedCount > 0) {
+          this.log(chalk.green(`Document${docPlural} updated successfully in collection '${collection}'`))
+          this.log(chalk.dim(`   Collection: ${collection}`))
+          this.log(chalk.dim(`   Matched Count: ${result.matchedCount}`))
+          this.log(chalk.dim(`   Modified Count: ${result.modifiedCount}`))
+        } else {
+          this.log(chalk.green(`${result.matchedCount} matching document${docPlural} found in collection '${collection}', but no update was necessary`))
+        }
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      } else if (result.upsertedId) {
+        this.log(chalk.green(`Document created (upserted) in collection '${collection}'`))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+        this.log(chalk.dim(`   Upserted ID: ${result.upsertedId}`))
+        this.log(chalk.dim(`   Upserted count: ${result.upsertedCount}`))
+      } else {
+        this.log(chalk.yellow(`No document found in collection '${collection}' matching the filter`))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      }
+
+      this.log(chalk.dim(`   Updated: ${new Date().toLocaleString()}`))
+
+      return response
+    } catch (error) {
+      this.debugLogger?.error?.(`Error updating document${docPlural}:`, error)
+
+      const errorMessage = `Failed to update document${docPlural} in collection '${collection}': ${error.message}`
+
+      this.log(chalk.red(`Failed to update document${docPlural}`))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+
+      this.error(errorMessage)
+    }
+  }
+}
+
+Update.description = 'Update document(s) in a collection'
+
+Update.examples = [
+  '$ aio app db document update users \'{"name": "John"}\' \'{"$set": {"age": 31}}\'',
+  '$ aio app db document update products \'{"id": "123"}\' \'{"$inc": {"stock": -1}}\' --json',
+  '$ aio app db document update posts \'{"slug": "hello-world"}\' \'{"$set": {"status": "published"}}\' --many',
+  '$ aio app db doc update users \'{"email": "john@example.com"}\' \'{"$set": {"lastLogin": "2024-01-01"}}\' --upsert'
+]
+
+Update.args = {
+  collection: Args.string({
+    name: 'collection',
+    description: 'The name of the collection',
+    required: true,
+    parse: input => isNonEmptyString(input, 'Collection name')
+  }),
+  filter: Args.string({
+    name: 'filter',
+    description: 'The filter document (JSON string)',
+    required: true,
+    parse: input => asObject(input, 'Filter')
+  }),
+  update: Args.string({
+    name: 'update',
+    description: 'The update document (JSON string)',
+    required: true,
+    parse: input => asObject(input, 'Update')
+  })
+}
+
+Update.flags = {
+  ...DBBaseCommand.flags,
+  upsert: Flags.boolean({
+    char: 'u',
+    description: 'If no document is found, create a new one',
+    default: false
+  }),
+  many: Flags.boolean({
+    char: 'm',
+    description: 'Update all documents matching the filter. Without this option, only the first matching document is updated.',
+    default: false
+  })
+}
+
+Update.aliases = ['app:db:doc:update']