@sap/cds 7.8.1 → 7.9.0

package/libx/_runtime/remote/Service.js

@@ -3,8 +3,8 @@ const cds = require('../cds')
 const { run, getReqOptions } = require('./utils/client')
 const { getCloudSdk, getCloudSdkConnectivity, getCloudSdkResilience } = require('./utils/cloudSdkProvider')
 const { hasAliasedColumns } = require('./utils/data')
-const { resolveView, getTransition, restoreLink, findQueryTarget } = require('../common/utils/resolveView')
-const { postProcess } = require('../common/utils/postProcessing')
+const { resolveView, getTransition, findQueryTarget } = require('../common/utils/resolveView')
+const postProcess = require('../common/utils/postProcess')
 const { formatVal } = require('../../odata/utils')
 
 const _isSimpleCqnQuery = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0
@@ -268,51 +268,28 @@ class RemoteService extends cds.Service {
     })
   }
 
-  // FIXME: This is a dirty hack for this situation:
-  // - This PR has cds.Service.model setter to always consistently apply cds.compile.for.odata, also for RemoteServices, which wasn't the case before
-  // - because of that tests/_runtime/remote/__tests__/integration/odata.test.js fails, which relies on the former behavior of RemoteServices
-  // NOTE: that test would never have worked for RemoteServices bootstrapped from single cds.model, which is always cds.compiled.for.odata
-  // REVISIT: should become obsolete with Universal CSN
-  // set model(m) {
-  //   const fn = cds.compile.for.odata
-  //   try {
-  //     cds.compile.for.odata = m => m
-  //     super.model = m
-  //   } finally {
-  //     cds.compile.for.odata = fn
-  //   }
-  // }
-
   // Overload .handle in order to resolve projections up to a definition that is known by the remote service instance.
   // Result is post processed according to the inverse projection in order to reflect the correct result of the original query.
   async handle(req) {
-    // compat mode
-    if (req._resolved || cds.env.features.resolve_views === false) return super.handle(req)
-
-    if (req.target && req.target.name && this.definition && req.target.name.startsWith(this.definition.name + '.')) {
-      const result = await super.handle(req)
+    if (req._resolved) return super.handle(req)
 
+    if (req.target?.name?.startsWith(this.definition?.name + '.')) {
+      let result = await super.handle(req)
       // only post process if alias was explicitly set in query
-      if (_selectOnlyWithAlias(req.query)) {
-        return postProcess(req.query, result, this, true)
-      }
-
+      if (_selectOnlyWithAlias(req.query)) result = postProcess(req.query, result, this, true)
       return result
     }
 
     // req.query can be:
     // - empty object in case of unbound action/function
     // - undefined/null in case of plain string queries
-    if (_isSimpleCqnQuery(req.query) && this.model) {
+    if (this.model && _isSimpleCqnQuery(req.query)) {
       const q = resolveView(req.query, this.model, this)
       const t = findQueryTarget(q) || req.target
 
-      // compat
-      restoreLink(req)
-
       // REVISIT: We need to provide target explicitly because it's cached already within ensure_target
-      const newReq = new cds.Request({ query: q, target: t, headers: req.headers, _resolved: true, method: req.method })
-      const result = await super.dispatch(newReq)
+      const _req = new cds.Request({ query: q, target: t, _resolved: true, headers: req.headers, method: req.method })
+      const result = await super.dispatch(_req)
       return postProcess(q, result, this, true)
     }
 

package/libx/_runtime/remote/utils/client.js

@@ -166,27 +166,17 @@ const TYPES_TO_REMOVE = { function: 1, object: 1 }
 const PROPS_TO_IGNORE = { cause: 1, name: 1 }
 
 const _getSanitizedError = (e, reqOptions, options = { suppressRemoteResponseBody: false, batchRequest: false }) => {
-  e.request = {
+  const request = {
     method: reqOptions.method,
     url: e.config ? e.config.baseURL + e.config.url : reqOptions.url,
     headers: e.config ? e.config.headers : reqOptions.headers
   }
-
-  if (options.batchRequest) {
-    e.request.body = reqOptions.data
-  }
+  if (options.batchRequest) request.body = reqOptions.data
+  e.request = request
 
   if (e.response) {
-    const response = {
-      status: e.response.status,
-      statusText: e.response.statusText,
-      headers: e.response.headers
-    }
-
-    if (e.response.data && !options.suppressRemoteResponseBody) {
-      response.body = e.response.data
-    }
-
+    const response = { status: e.response.status, statusText: e.response.statusText, headers: e.response.headers }
+    if (e.response.data && !options.suppressRemoteResponseBody) response.body = e.response.data
     e.response = response
   }
 
@@ -214,6 +204,11 @@ const _getSanitizedError = (e, reqOptions, options = { suppressRemoteResponseBod
     e = _e
   }
 
+  // AxiosError's toJSON() method doesn't include the request and response objects
+  e.toJSON = function () {
+    return { ...this.__proto__.toJSON(), request: this.request, response: this.response }
+  }
+
   return e
 }
 
@@ -232,7 +227,7 @@ const run = async (requestConfig, options) => {
   } catch (e) {
     // > axios received status >= 400 -> gateway error
     const msg = e?.response?.data?.error?.message?.value ?? e?.response?.data?.error?.message ?? e.message
-    e.message = msg ? 'Error during request to remote service: \n' + msg : 'Request to remote service failed.'
+    e.message = msg ? 'Error during request to remote service: ' + msg : 'Request to remote service failed.'
     const sanitizedError = _getSanitizedError(e, requestConfig, { suppressRemoteResponseBody })
     const err = Object.assign(new Error(e.message), { statusCode: 502, reason: sanitizedError })
     LOG._warn && LOG.warn(err)
@@ -251,11 +246,8 @@ const run = async (requestConfig, options) => {
     const e = new Error("Received content-type 'text/html' which is not part of accepted content types")
     e.response = response
     const sanitizedError = _getSanitizedError(e, requestConfig, { suppressRemoteResponseBody })
-    const err = Object.assign(new Error(`Error during request to remote service: ${e.message}`), {
-      statusCode: 502,
-      reason: sanitizedError
-    })
-
+    const message = 'Error during request to remote service: ' + e.message
+    const err = Object.assign(new Error(message), { statusCode: 502, reason: sanitizedError })
     LOG._warn && LOG.warn(err)
     throw err
   }

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -28,8 +28,14 @@ const _convert = (refEntries, req) => {
       // only check refs in format {ref: ['assoc', 'id']}
       continue
     }
+    let element
+    if (req.target.elements[refEntry.ref[0]]) {
+      element = req.target.elements[refEntry.ref[0]]
+    } else if (req.target.elements[refEntry.ref[1]]?.isAssociation) {
+      // fallback: if first ref is not an element and second is an association, we assume first is an alias
+      element = req.target.elements[refEntry.ref[1]]
+    }
 
-    const element = req.target.elements[refEntry.ref[0]]
     if (!element || !element.is2one) return
 
     _convertRefForAssocToOneManaged(element, refEntry)

package/libx/_runtime/sqlite/execute.js

@@ -302,7 +302,7 @@ function executeGenericCQN(model, dbc, cqn, user, locale, txTimestamp) {
 
 // REVISIT: consider deleting this function after removing stream_compat
 async function executeSelectStreamCQN({ model, dbc, query, user, locale, txTimestamp }) {
-  const result = await executeSelectCQN(model, dbc, query, user, locale, txTimestamp)
+  let result = await executeSelectCQN(model, dbc, query, user, locale, txTimestamp)
 
   if (result == null || result.length === 0) {
     return
@@ -313,7 +313,9 @@ async function executeSelectStreamCQN({ model, dbc, query, user, locale, txTimes
     return result
   }
 
-  let val = Array.isArray(result) ? Object.values(result[0])[0] : Object.values(result)[0]
+  // REVISIT: following code to be deleted after cds.env.features.stream_compat is removed
+  if (Array.isArray(result)) result = result[0]
+  let [key, val] = Object.entries(result)[0]
   if (val === null) {
     return null
   }
@@ -325,7 +327,10 @@ async function executeSelectStreamCQN({ model, dbc, query, user, locale, txTimes
   stream_.push(val)
   stream_.push(null)
 
-  return { value: stream_ }
+  result.value = stream_
+  delete result[key]
+
+  return result
 }
 
 module.exports = {

package/libx/_runtime/ucl/Service.js

@@ -0,0 +1,259 @@
+const cds = require('../cds')
+const LOG = cds.log('ucl')
+
+const https = require('https')
+
+class UCLService extends cds.Service {
+  async init() {
+    await super.init()
+    this.validate()
+    this._register()
+    this.agent = this.getAgent()
+  }
+
+  getAgent() {
+    try {
+      if (this.options.x509.certPath && this.options.x509.pkeyPath) {
+        return new https.Agent({
+          cert: cds.utils.fs.readFileSync(cds.utils.path.resolve(cds.root, this.options.x509.certPath)),
+          key: cds.utils.fs.readFileSync(cds.utils.path.resolve(cds.root, this.options.x509.pkeyPath))
+        })
+      }
+    } catch (error) {
+      if (LOG) LOG.error('GetCredentials', { error: error.message })
+      throw error
+    }
+  }
+
+  async _registerProvisioningEvents() {
+    var provisioning
+    try {
+      provisioning = await cds.connect.to('cds.xt.SaasProvisioningService')
+    } catch (error) {
+      throw new Error(
+        "Provisioning service 'cds.xt.SaasProvisioningService' can not be found, therefore mode is not multitenant. Single tenant applications are not supported."
+      )
+    }
+    if (provisioning) {
+      provisioning.prepend(() => {
+        provisioning.on('dependencies', async (_, next) => {
+          let dependencies = await next()
+          const xsappnameCMPClone = await this._getUCLDependency()
+          dependencies.push({ xsappname: xsappnameCMPClone })
+          return dependencies
+        })
+      })
+    }
+  }
+
+  validate() {
+    if (!this.options.namespace) {
+      throw new Error(
+        'UCL integrator requires an application namespace. You can set environment variable SAP_APPLICATION_NAMESPACE or you can give namespace as an option in your cds.requires section as described in documentation'
+      )
+    }
+    if (!cds.requires.multitenancy && cds.env.profile !== 'mtx-sidecar') {
+      throw new Error('[ucl] - Currently only multitenant applications are supported.')
+    }
+    if (!this.options.systemType || !this.options.systemDescription) {
+      throw new Error(
+        'systemType and systemDescription is obligatory parameters, please fill as shown in documentation'
+      )
+    }
+  }
+
+  async readTemplate() {
+    const xsappname = this.options.credentials.xsappname
+    const query = `
+      query ($key: String!, $value: String!) {
+        applicationTemplates(filter: { key: $key, query: $value }) {
+          data {
+            id
+            name
+            description
+            placeholders {
+              name
+              description
+            }
+            applicationInput
+            labels
+            webhooks {
+              type
+            }
+          }
+        }
+      }
+    `
+    const variables = { key: 'xsappname', value: `"${xsappname}"` }
+    return (await this.request(query, variables)).applicationTemplates.data[0]
+  }
+
+  async _createTemplate() {
+    const xsappname = this.options.credentials.xsappname
+    const query = `mutation {
+          result: createApplicationTemplate (
+              in: {
+              name: "${this.options.systemType}"
+              description: "${this.options.systemDescription}"
+              applicationInput: {
+                  name: "${this.options.systemType}" 
+                  description: "${this.options.systemDescription}"
+                  providerName: "${this.options.provider}" 
+                  localTenantID: "{{tenant-id}}"
+                  labels: {
+                  displayName: "{{subdomain}}"
+                  }
+              }
+              placeholders: [
+                  { name: "subdomain", description: "The subdomain of the consumer tenant" }
+                  { name: "tenant-id", description: "The tenant id as it's known in the product's domain", jsonPath: "$.subscribedSubaccountId" }
+              ]
+              labels: {
+                  managed_app_provisioning: true
+                  xsappname: "${xsappname}"
+              }
+              applicationNamespace: "${this.options.namespace}"
+              accessLevel: GLOBAL
+              }
+          ) {
+              id
+              name
+              labels
+              applicationInput 
+              applicationNamespace
+          }
+      }`
+    try {
+      return this.handleResponse(await this.request(query))
+    } catch (e) {
+      this.handleResponse(e)
+    }
+  }
+
+  handleResponse(result) {
+    if (result.response && result.response.errors) {
+      let errorMessage = result.response.errors[0].message
+      throw new Error(errorMessage)
+    } else {
+      return result.result
+    }
+  }
+
+  async deleteTemplate() {
+    const template = await this.readTemplate()
+    if (!template) return
+    const query = `mutation {
+            result: deleteApplicationTemplate(
+              id: "${template.id}"
+            ){
+                id
+                name
+                description
+            }
+        }`
+    return this.handleResponse(await this.request(query))
+  }
+
+  async _getUCLDependency() {
+    if (!this.template) {
+      throw Error('Application template not found on UCL!')
+    }
+    return this.template.labels.xsappnameCMPClone
+  }
+
+  // Replace with fetch
+  async request(query, variables) {
+    const opts = {
+      host: this.options.host,
+      path: this.options.path,
+      agent: this.agent,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const req = https.request(opts, res => {
+        const chunks = []
+
+        res.on('data', chunk => {
+          chunks.push(chunk)
+        })
+
+        res.on('end', () => {
+          const response = {
+            statusCode: res.statusCode,
+            headers: res.headers,
+            body: Buffer.concat(chunks).toString()
+          }
+          resolve(JSON.parse(response.body).data)
+        })
+      })
+
+      req.on('error', error => {
+        reject(error)
+      })
+
+      if (query) {
+        req.write(JSON.stringify({ query, variables }))
+      }
+      req.end()
+    })
+  }
+
+  async _registerApplicationTemplate() {
+    this.template = await this.readTemplate()
+    if (!this.template) {
+      LOG.info('Application Template cannot be found therefore created.')
+      await this._createTemplate()
+    } else {
+      await this._updateTemplate(this.template)
+    }
+  }
+
+  async _updateTemplate(template) {
+    const query = `mutation {
+    result: updateApplicationTemplate(
+      id: "${template.id}"
+      in: {
+        name: "${this.options.systemType}"
+        description: "${this.options.systemDescription}"
+        applicationInput: {
+          name: "${this.options.systemType}"
+          description: "${this.options.systemDescription}"
+          providerName: "${this.options.provider}" 
+          localTenantID: "{{tenant-id}}"
+          labels: { displayName: "{{subdomain}}" }
+        }
+        applicationNamespace: "${this.options.namespace}"
+        placeholders: [
+            { name: "subdomain", description: "The subdomain of the consumer tenant" }
+            { name: "tenant-id", description: "The tenant id as it's known in the product's domain", jsonPath: "$.subscribedSubaccountId" }
+        ]
+        accessLevel: GLOBAL
+      }
+    ) {
+      id
+      name
+      description
+      applicationInput
+    }
+  }`
+    try {
+      const response = this.handleResponse(await this.request(query))
+      LOG.info('Application template updated successfully.')
+      return response
+    } catch (e) {
+      this.handleResponse(e)
+    }
+  }
+
+  _register() {
+    cds.once('listening', async () => {
+      await this._registerApplicationTemplate()
+      this._registerProvisioningEvents()
+    })
+  }
+}
+
+module.exports = UCLService

package/libx/common/assert/index.js

@@ -2,14 +2,14 @@ const { cds } = global
 
 const typeCheckers = require('./type')
 const { checkMandatory, checkEnum, checkRange, checkFormat } = require('./validation')
-const { getNested, getTarget, resolveCDSType, resolveSegment } = require('./utils')
+const { getNested, getNormalizedDecimal, getTarget, resolveCDSType, resolveSegment } = require('./utils')
 
 const NUMBER_TYPES = new Set(['cds.UInt8', 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Double'])
 
 const _no_op = () => {}
 
 const _reject_unknown = (_, k, def, errs) =>
-  errs.push(new cds.error(`Property ${k} does not exist in ${def.name}`, { statusCode: 400, code: '400' }))
+  errs.push(new cds.error(`Property "${k}" does not exist in ${def.name}`, { statusCode: 400, code: '400' }))
 
 const _filter_unknown = (obj, k) => delete obj[k]
 
@@ -57,6 +57,7 @@ function _process(obj, def, errs, opts) {
 
   for (let [k, v] of Object.entries(obj)) {
     let ele = def.elements?.[k] || def.params?.[k] || def.items
+    if (typeof ele !== 'object') ele = undefined //> ignore non-object elements, e.g., functions of prototypes
 
     /*
      * TODO: should we support this? with or without transformation?
@@ -140,15 +141,9 @@ function _process(obj, def, errs, opts) {
       // if used in protocol adapter, adjust val/ checker if necessary
       if (opts.http) {
         if (typeof v !== 'boolean') {
-          if (NUMBER_TYPES.has(type)) v = Number(v)
-          else if (type === 'cds.Double') v = parseFloat(v)
-
-          // REVISIT: consider ieee754 and exp dec headers?
-          // const ieee = opts.http.req?.headers['content-type'].match(/IEEE754Compatible=(\w+)/i)
-          // const exp = opts.http.req?.headers['content-type'].match(/ExponentialDecimals=(\w+)/i)
-          // if (type === 'cds.Decimal') {
-          //   TODO
-          // }
+          if (type === 'cds.Decimal') v = getNormalizedDecimal(v)
+          else if (type === 'cds.Int64') v = String(v)
+          else if (NUMBER_TYPES.has(type)) v = Number(v)
         }
       }
 

package/libx/common/assert/validation.js

@@ -73,7 +73,12 @@ const checkMandatory = (v, ele, errs, path, k) => {
 const checkEnum = (v, ele, errs, path, k) => {
   const enumElements = _getEnumElement(ele)
   const enumValues = enumElements && _enumValues(enumElements)
-  if (enumElements && !enumValues.includes(v)) {
+  const includes = (enumValues, v) => {
+    if (ele._type in { 'cds.Decimal': 1, 'cds.Int64': 1 }) {
+      return enumValues.map(ev => String(ev)).includes(String(v))
+    } else return enumValues.includes(v)
+  }
+  if (enumElements && !includes(enumValues, v)) {
     const args =
       typeof v === 'string'
         ? ['"' + v + '"', enumValues.map(ele => '"' + ele + '"').join(', ')]

package/libx/odata/index.js

@@ -9,28 +9,59 @@ const afterburner = require('./parse/afterburner')
 const { getSafeNumber: safeNumber } = require('./utils')
 const getError = require('../_runtime/common/error')
 
+// used for function validation in peggy parser
+// -----  should all be lowercase, as peggy compares to lowercase  -----
+// (plus: odata is case insensitive)
 const strict = {
   functions: {
+    // --- String + Collection: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31360980
+    concat: 1,
     contains: 1,
-    startswith: 1,
     endswith: 1,
-    tolower: 1,
-    toupper: 1,
-    length: 1,
     indexof: 1,
+    length: 1,
+    startswith: 1,
     substring: 1,
+    // --- Collection: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31360988
+    // REVISIT: not supported
+    // hassubset:1,
+    // hassubsequence:1,
+    // --- String: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31360991
+    matchespattern: 1,
+    tolower: 1,
+    toupper: 1,
     trim: 1,
-    concat: 1,
-    year: 1,
-    month: 1,
+    // --- Date + Time: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31360996
+    date: 1,
     day: 1,
+    fractionalseconds: 1,
     hour: 1,
+    maxdatetime: 1,
+    mindatetime: 1,
     minute: 1,
+    month: 1,
+    now: 1,
     second: 1,
     time: 1,
-    now: 1,
+    totaloffsetminutes: 1,
+    totalseconds: 1,
+    year: 1,
+    // --- Arithemetic: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31361011
+    ceiling: 1,
+    floor: 1,
     round: 1,
-    date: 1
+    // --- Type: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31361015
+    // REVISIT: not supported
+    // cast: 1,
+    // REVISIT: has to be implemented inside the odata adapter
+    // isof: 1,
+    // --- Geo: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31361018
+    // REVISIT: not supported
+    // 'geo.distance': 1,
+    // 'geo.intersects': 1,
+    // 'geo.length': 1,
+    // --- Conditional: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#_Toc31361022
+    case: 1
   }
 }
 
@@ -67,10 +98,8 @@ module.exports = {
   parse: (url, options = {}) => {
     // first arg may also be req
     if (url.url) url = url.url
-    // REVISIT: for okra, remove when no longer needed
-    else if (url.getIncomingRequest) url = url.getIncomingRequest().url
 
-    url = decodeURIComponent(url) // REVISIT: do we need that?
+    url = decodeURIComponent(url)
 
     options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
     if (options.service) Object.assign(options, { minimal: true, afterburner: afterburner.for(options.service) })
@@ -81,18 +110,13 @@ module.exports = {
     try {
       cqn = odata2cqn(url, options)
     } catch (err) {
-      if (err.statusCode === 501) {
-        throw getError(err.statusCode, err.message)
-      }
+      if (err.statusCode === 501) throw getError(err.statusCode, err.message)
 
       let offset = err.location && err.location.start.offset
-      if (!offset && err.statusCode && err.message) {
-        throw err
-      }
-      if (options.baseUrl) {
-        // we need to add the number of chars from base url to the offset
-        offset += options.baseUrl.length
-      }
+      if (!offset && err.statusCode && err.message) throw err
+
+      // we need to add the number of chars from base url to the offset
+      offset += options.baseUrl ? options.baseUrl.length : 0
 
       // TODO adjust this to behave like above
       err.message = `Parsing URL failed at position ${offset}: ${err.message}`
@@ -102,9 +126,7 @@ module.exports = {
 
     // cqn is an array, if concat is used
     if (Array.isArray(cqn)) {
-      for (let i = 0; i < cqn.length; i++) {
-        cqn[i] = enhanceCqn(cqn[i], options)
-      }
+      for (let i = 0; i < cqn.length; i++) cqn[i] = enhanceCqn(cqn[i], options)
     } else {
       cqn = enhanceCqn(cqn, options)
     }

package/libx/odata/middleware/batch.js

@@ -4,6 +4,8 @@ const { AsyncResource } = require('async_hooks')
 // eslint-disable-next-line cds/no-missing-dependencies
 const express = require('express')
 const { STATUS_CODES } = require('http')
+const qs = require('querystring')
+const { URL } = require('url')
 
 const multipartToJson = require('../parse/multipartToJson')
 
@@ -35,6 +37,9 @@ const _validateBatch = body => {
 
   _validateProperty('requests', requests, 'Array')
 
+  if (requests.length > cds.env.odata.batch_limit)
+    cds.error('BATCH_TOO_MANY_REQ', { code: 'BATCH_TOO_MANY_REQ', statusCode: 429 })
+
   const ids = {}
 
   let previousAtomicityGroup
@@ -115,15 +120,11 @@ const _createExpressReqResLookalike = (request, _req, _res) => {
 
   req.method = method.toUpperCase()
   req.url = url
-  req.query = {}
+  const u = new URL(url, 'http://cap')
+  req.query = qs.parse(u.search.slice(1))
   req.headers = request.headers || {}
   req.body = request.body
 
-  // propagate user, tenant and locale
-  req.user = _req.user
-  req.tenant = _req.tenant
-  req.locale = _req.locale
-
   const res = (ret.res = new express.response.constructor(req))
   res.__proto__ = express.response
 
@@ -270,7 +271,7 @@ const _formatResponseMultipart = (request, res, boundary) => {
       let meta = [],
         data = []
       for (const [k, v] of Object.entries(_json)) {
-        if (k.startsWith('@')) meta.push(`"${k}":"${v}"`)
+        if (k.startsWith('@')) meta.push(`"${k}":"${v.replaceAll('"', '\\"')}"`)
         else data.push(JSON.stringify({ [k]: v }).slice(1, -1))
       }
       const _json_as_txt = '{' + meta.join(',') + (meta.length && data.length ? ',' : '') + data.join(',') + '}'