@radio-garden/ditojs-server 2.85.2-0.5067ad799

package/src/utils/fs.js

@@ -0,0 +1,10 @@
+import fs from 'fs/promises'
+
+export async function exists(path) {
+  try {
+    await fs.access(path)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/utils/function.js

@@ -0,0 +1,17 @@
+export function describeFunction(func) {
+  // A helper that describes a method by turning it int a short version without
+  // printing its body.
+  const match = func.toString().match(
+    /^\s*(async\s*|)(?:function[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|(\S*)\s*=>)\s*(.)/
+  )
+  if (match) {
+    const body = match[5] === '{' ? '{ ... }' : '...'
+    return match[2] !== undefined
+      ? `${match[1]}function (${match[2]}) ${body}`
+      : match[3] !== undefined
+        ? `${match[1]}(${match[3]}) => ${body}`
+        : match[4] !== undefined
+          ? `${match[1]}${match[4]} => ${body}`
+          : ''
+  }
+}

package/src/utils/function.test.js

@@ -0,0 +1,77 @@
+import { describeFunction } from './function.js'
+
+describe('describeFunction()', () => {
+  it('describes normal functions', () => {
+    expect(
+      describeFunction(function (a, b, c) {
+        return a + b + c
+      })
+    )
+      .toBe('function (a, b, c) { ... }')
+  })
+
+  it('describes lambdas with one param and a body', () => {
+    expect(
+      describeFunction(a => {
+        return a
+      })
+    )
+      .toBe('a => { ... }')
+  })
+
+  it('describes lambdas with one param and no body', () => {
+    expect(describeFunction(a => a))
+      .toBe('a => ...')
+  })
+
+  it('describes lambdas with multiple params and a body', () => {
+    expect(
+      describeFunction((a, b, c) => {
+        return a + b + c
+      })
+    )
+      .toBe('(a, b, c) => { ... }')
+  })
+
+  it('describes lambdas with multiple params and no body', () => {
+    expect(describeFunction((a, b, c) => a + b + c))
+      .toBe('(a, b, c) => ...')
+  })
+
+  it('describes async functions', () => {
+    expect(
+      describeFunction(async function (a, b, c) {
+        return a + b + c
+      })
+    )
+      .toBe('async function (a, b, c) { ... }')
+  })
+
+  it('describes async lambdas with one param and a body', () => {
+    expect(
+      describeFunction(async a => {
+        return a
+      })
+    )
+      .toBe('async a => { ... }')
+  })
+
+  it('describes async lambdas with one param and no body', () => {
+    expect(describeFunction(async a => a))
+      .toBe('async a => ...')
+  })
+
+  it('describes async lambdas with multiple params and a body', () => {
+    expect(
+      describeFunction(async (a, b, c) => {
+        return a + b + c
+      })
+    )
+      .toBe('async (a, b, c) => { ... }')
+  })
+
+  it('describes async lambdas with multiple params and no body', () => {
+    expect(describeFunction(async (a, b, c) => a + b + c))
+      .toBe('async (a, b, c) => ...')
+  })
+})

package/src/utils/handler.js

@@ -0,0 +1,17 @@
+import { asArray } from '@ditojs/utils'
+
+export function processHandlerParameters(handler, name, value) {
+  if (value) {
+    const [schema, options] = asArray(value)
+    handler[name] = schema
+
+    // If validation options are provided, expose them through
+    // `handler.options[name]`, see `ControllerAction`.
+    if (options) {
+      handler.options = {
+        ...handler.options,
+        [name]: options
+      }
+    }
+  }
+}

package/src/utils/json.js

@@ -0,0 +1,3 @@
+export function formatJson(json, indented = true) {
+  return JSON.stringify(json, null, indented ? 2 : 0)
+}

package/src/utils/model.js

@@ -0,0 +1,35 @@
+import { isPlainObject, isPlainArray } from '@ditojs/utils'
+
+/**
+ * Converts Models to their external representation by calling the `$toJson()`
+ * method. It does not create a JSON string, but a plain object. It is necessary
+ * to do this before the validation is performed, otherwise different properties
+ * might end up in the Json response. This is done recursively, so that nested
+ * models are also converted. Streams, Buffers and other non plain objects are
+ * left as-is, so this can directly be used on any results.
+ */
+export function convertModelsToJson(value) {
+  return value?.$isObjectionModel
+    ? value.$toJson()
+    : isPlainObject(value)
+      ? convertToJsonObject(value)
+      : isPlainArray(value)
+        ? convertToJsonArray(value)
+        : value
+}
+
+function convertToJsonObject(value) {
+  const object = {}
+  for (const key of Object.keys(value)) {
+    object[key] = convertModelsToJson(value[key])
+  }
+  return object
+}
+
+function convertToJsonArray(value) {
+  const array = new Array(value.length)
+  for (let i = 0, l = value.length; i < l; ++i) {
+    array[i] = convertModelsToJson(value[i])
+  }
+  return array
+}

package/src/utils/net.js

@@ -0,0 +1,17 @@
+import net from 'net'
+
+export async function getRandomFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer()
+    srv.listen(0, () => {
+      const { port } = srv.address()
+      srv.close(err => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(port)
+        }
+      })
+    })
+  })
+}

package/src/utils/object.js

@@ -0,0 +1,82 @@
+import { asArray } from '@ditojs/utils'
+
+export const getOwnKeys = Object.keys
+
+export function getAllKeys(object) {
+  // Unlike `getOwnKeys()`, this returns all enumerable keys not just own ones.
+  const keys = []
+  for (const key in object) {
+    keys.push(key)
+  }
+  return keys
+}
+
+export function getOwnProperty(object, key) {
+  return object.hasOwnProperty(key) ? object[key] : undefined
+}
+
+export function createLookup(keys) {
+  return asArray(keys).reduce((obj, key) => {
+    obj[key] = true
+    return obj
+  }, Object.create(null))
+}
+
+export function mergeReversed(objects) {
+  return Object.assign({}, ...[...objects].reverse())
+}
+
+export function mergeReversedOrNull(objects) {
+  const merged = mergeReversed(objects)
+  return Object.keys(merged).length > 0 ? merged : null
+}
+
+export function mergeAsReversedArrays(objects) {
+  const res = {}
+  for (const object of objects) {
+    for (const key in object) {
+      const value = object[key]
+      if (key in res) {
+        res[key].unshift(value)
+      } else {
+        res[key] = [value]
+      }
+    }
+  }
+  return res
+}
+
+export function getInheritanceChain(object) {
+  // Returns an array of objects from the inheritance chain of `object`,
+  // starting with the object itself and ending at `Object.prototype`.
+  const chain = []
+  let current = object
+  while (current && current !== Object.prototype) {
+    chain.push(current)
+    current = Object.getPrototypeOf(current)
+  }
+  return chain
+}
+
+export function setupPropertyInheritance(object, key, baseValue = null) {
+  // Loops through the inheritance chain of `object` and sets up a related
+  // inheritance chain for the given property `key`. The resulting value with
+  // proper inheritance is returned.
+  let [current, ...parents] = getInheritanceChain(object)
+  for (const parent of parents) {
+    if (current.hasOwnProperty(key)) {
+      const value = current[key]
+      const parentValue = parent[key] || baseValue
+      if (parentValue) {
+        Object.setPrototypeOf(value, parentValue)
+      }
+    }
+    current = parent
+  }
+  if (baseValue && !(key in object)) {
+    // If there wasn't any override in the chain, and we have a baseValue,
+    // set up direct inheritance from that now.
+    object[key] = Object.setPrototypeOf({}, baseValue)
+  }
+  return object[key]
+}

package/src/utils/object.test.js

@@ -0,0 +1,86 @@
+import {
+  getAllKeys,
+  getOwnProperty,
+  createLookup,
+  mergeReversed,
+  mergeAsReversedArrays
+} from './object.js'
+
+const object = Object.create({ a: 1 })
+object.b = 2
+
+describe('getAllKeys()', () => {
+  it('returns all keys, not just own keys', () => {
+    expect(getAllKeys(object)).toEqual(['b', 'a'])
+  })
+})
+
+describe('getOwnProperty()', () => {
+  it('only returns own properties', () => {
+    expect(getOwnProperty(object, 'a')).toBeUndefined()
+    expect(getOwnProperty(object, 'b')).toBe(2)
+  })
+})
+
+describe('createLookup()', () => {
+  it('creates lookup objects out of arrays of strings', () => {
+    expect(createLookup(['a', 'b'])).toEqual({
+      a: true,
+      b: true
+    })
+  })
+})
+
+describe('mergeReversed()', () => {
+  it('merges property values in reversed order', () => {
+    expect(
+      mergeReversed([
+        {
+          a: 3
+        },
+        {
+          a: 2,
+          b: 2
+        },
+        {
+          a: 1,
+          b: 1,
+          c: 1
+        }
+      ])
+    ).toEqual({
+      a: 3,
+      b: 2,
+      c: 1
+    })
+  })
+})
+
+describe('mergeAsReversedArrays()', () => {
+  it('merges property values into arrays', () => {
+    expect(
+      mergeAsReversedArrays([
+        {
+          a: 1,
+          b: 1,
+          c: 1
+        },
+        {
+          a: 2,
+          b: 2
+        },
+        {
+          a: 3
+        }
+      ])
+    ).toEqual({
+      a: [3, 2, 1],
+      b: [2, 1],
+      c: [1]
+    })
+  })
+})
+
+describe.skip('setupPropertyInheritance()', () => {
+  // TODO: Add unit tests for this!
+})

package/src/utils/scope.js

@@ -0,0 +1,7 @@
+export function getScope(expr) {
+  // See if this an graph scope, and if so, remove the trailing ^ for
+  // internal handling.
+  const graph = expr?.[0] === '^'
+  const scope = graph ? expr.slice(1) : expr
+  return { scope, graph }
+}