@toa.io/norm 0.2.1-dev.1

package/src/component.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const { join } = require('node:path')
+
+const { load: yaml } = require('@toa.io/yaml')
+const { directory: { find } } = require('@toa.io/filesystem')
+const { Locator } = require('@toa.io/core')
+
+const {
+  expand,
+  merge,
+  validate,
+  collapse,
+  dereference,
+  defaults,
+  normalize
+} = require('./.component')
+
+/**
+ * @type {toa.norm.component.Constructor}
+ */
+const component = async (path) => {
+  const manifest = await load(path)
+
+  normalize(manifest, process.env.TOA_ENV)
+  validate(manifest)
+
+  return manifest
+}
+
+const load = async (path, base) => {
+  if (base !== undefined) path = find(path, base, MANIFEST)
+
+  const file = join(path, MANIFEST)
+  const manifest = await yaml(file)
+
+  manifest.path = path
+
+  defaults(manifest)
+  expand(manifest)
+
+  await merge(path, manifest)
+
+  if (manifest.prototype !== null) {
+    manifest.locator = new Locator(manifest.name, manifest.namespace)
+
+    const prototype = await load(manifest.prototype, path)
+
+    collapse(manifest, prototype)
+  }
+
+  dereference(manifest)
+
+  return manifest
+}
+
+const MANIFEST = 'manifest.toa.yaml'
+
+exports.component = component

package/src/context.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const { convolve } = require('@toa.io/generic')
+const { directory: { glob } } = require('@toa.io/filesystem')
+const { load } = require('@toa.io/yaml')
+
+const { component } = require('./component')
+
+const {
+  dependencies,
+  normalize,
+  complete,
+  dereference,
+  expand,
+  validate
+} = require('./.context')
+
+/**
+ * @type {toa.norm.context.Constructor}
+ */
+const context = async (root, environment = undefined) => {
+  const path = resolve(root, CONTEXT)
+  const context = /** @type {toa.norm.Context} */ await load(path)
+  const pattern = resolve(root, context.packages)
+
+  context.environment = environment
+
+  convolve(context, environment)
+  expand(context)
+  normalize(context)
+
+  validate(context)
+
+  const paths = await glob(pattern)
+
+  context.components = await Promise.all(paths.map(component))
+  context.dependencies = dependencies(context)
+
+  dereference(context)
+  complete(context)
+
+  return context
+}
+
+const CONTEXT = 'context.toa.yaml'
+
+exports.context = context

package/src/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { context } = require('./context')
+const { component } = require('./component')
+
+exports.shortcuts = require('./shortcuts')
+
+exports.context = context
+exports.component = component

package/src/shortcuts.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { empty, merge } = require('@toa.io/generic')
+
+/**
+ * Resolves shortcuts
+ *
+ * @param {string} token
+ * @returns {string}
+ */
+const resolve = (token) => {
+  if (token in SHORTCUTS) return SHORTCUTS[token]
+  else return token
+}
+
+/**
+ * Finds object keys with known shortcuts, resolves and groups them to a given group key if provided
+ *
+ * @param {Object} object
+ * @param {string} [group]
+ */
+const recognize = (object, group) => {
+  if (object === undefined) return
+
+  const target = group === undefined ? object : {}
+
+  for (const [alias, name] of Object.entries(SHORTCUTS)) {
+    const value = object[alias]
+
+    if (value === undefined) continue
+
+    delete object[alias]
+
+    target[name] = value
+  }
+
+  if (group !== undefined && !empty(target)) object[group] = merge(object[group], target)
+}
+
+const SHORTCUTS = {
+  http: '@toa.io/bindings.http',
+  amqp: '@toa.io/bindings.amqp',
+  node: '@toa.io/bridges.node',
+  mongodb: '@toa.io/storages.mongodb',
+  sql: '@toa.io/storages.sql',
+  exposition: '@toa.io/extensions.exposition',
+  origins: '@toa.io/extensions.origins',
+  configuration: '@toa.io/extensions.configuration'
+}
+
+exports.recognize = recognize
+exports.resolve = resolve

package/test/component/collapse.fixtures.js

@@ -0,0 +1,134 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const entity = {
+  manifest: {
+    entity: {
+      schema: {
+        properties: {
+          foo: {
+            type: 'string'
+          },
+          bar: {
+            type: 'integer'
+          }
+        },
+        required: ['foo']
+      }
+    }
+  },
+  prototype: {
+    entity: {
+      schema: {
+        properties: {
+          foo: {
+            default: 'ok'
+          },
+          baz: {
+            type: 'boolean'
+          }
+        },
+        required: ['baz']
+      }
+    }
+  },
+  result: {
+    entity: {
+      schema: {
+        properties: {
+          foo: {
+            type: 'string',
+            default: 'ok'
+          },
+          bar: {
+            type: 'integer'
+          },
+          baz: {
+            type: 'boolean'
+          }
+        },
+        required: ['foo', 'baz']
+      }
+    }
+  }
+}
+
+const operations = {
+  manifest: {
+    operations: {
+      add: {
+        bridge: 'b',
+        query: false
+      },
+      get: {
+        bridge: 'b'
+      },
+      find: {
+        bridge: 'b'
+      }
+    }
+  },
+  prototype: {
+    prototype: null,
+    path: generate(),
+    operations: {
+      add: {
+        bridge: 'a'
+      },
+      find: {
+        bridge: 'a'
+      },
+      observe: {
+        bridge: 'a',
+        input: 'object'
+      }
+    }
+  },
+  result: {
+    prototype: {
+      prototype: null,
+      path: expect.any(String),
+      operations: {
+        add: {
+          bridge: 'a'
+        },
+        find: {
+          bridge: 'a'
+        },
+        observe: {
+          bridge: 'a'
+        }
+      }
+    },
+    operations: {
+      add: {
+        bridge: 'b',
+        query: false
+      },
+      get: {
+        bridge: 'b'
+      },
+      find: {
+        bridge: 'b'
+      },
+      observe: {
+        input: 'object'
+      }
+    }
+  }
+}
+
+const remotes = {
+  manifest: {
+    remotes: ['a', 'b']
+  },
+  prototype: {
+    remotes: ['c', 'd']
+  },
+  result: {
+    remotes: ['a', 'b', 'c', 'd']
+  }
+}
+
+exports.samples = { entity, operations, remotes }

package/test/component/collapse.test.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const fixtures = require('./collapse.fixtures')
+const { collapse } = require('../../src/.component')
+
+let samples
+
+beforeEach(() => {
+  samples = clone(fixtures.samples)
+})
+
+it('should ignore locator', () => {
+  const source = {}
+  const prototype = { namespace: 'foo1', name: 'bar1' }
+  const manifest = clone(source)
+
+  collapse(manifest, prototype)
+
+  expect(manifest).toStrictEqual(source)
+})
+
+it('should remove prototype property', () => {
+  const manifest = { prototype: 'a' }
+
+  collapse(manifest, {})
+
+  expect(manifest).toStrictEqual({})
+})
+
+describe('entity', () => {
+  it('should ignore storage', () => {
+    const source = { entity: { storage: 'foo' } }
+    const prototype = { entity: { storage: 'bar' } }
+    const manifest = clone(source)
+
+    collapse(manifest, prototype)
+    expect(manifest).toStrictEqual(source)
+
+    delete manifest.entity.storage
+    collapse(manifest, prototype)
+    expect(manifest).toStrictEqual({ entity: {} })
+  })
+
+  it('should merge entity schema', () => {
+    const manifest = clone(samples.entity.manifest)
+
+    collapse(manifest, samples.entity.prototype)
+    expect(manifest).toStrictEqual(samples.entity.result)
+  })
+})
+
+it('should ignore bindings', () => {
+  const source = { bindings: ['foo'] }
+  const prototype = { bindings: ['bar'] }
+  const manifest = clone(source)
+
+  collapse(manifest, prototype)
+  expect(manifest).toStrictEqual(source)
+
+  delete manifest.bindings
+  collapse(manifest, prototype)
+  expect(manifest).toStrictEqual({})
+})
+
+it('should merge operations', () => {
+  const manifest = clone(samples.operations.manifest)
+  const prototype = clone(samples.operations.prototype)
+
+  collapse(manifest, prototype, '/somewhere')
+  expect(manifest).toStrictEqual(samples.operations.result)
+})
+
+it('should merge remotes', () => {
+  const manifest = clone(samples.remotes.manifest)
+  const prototype = clone(samples.remotes.prototype)
+
+  collapse(manifest, prototype, '/somewhere')
+  expect(manifest).toStrictEqual(samples.remotes.result)
+})

package/test/component/dereference.fixtures.js

@@ -0,0 +1,165 @@
+'use strict'
+
+const source = {
+  entity: {
+    schema: {
+      properties: {
+        foo: {
+          type: 'string'
+        },
+        bar: {
+          type: 'string',
+          default: '.foo'
+        }
+      }
+    }
+  },
+  operations: {
+    transit: {
+      input: {
+        properties: {
+          foo: {
+            type: 'string',
+            default: '.'
+          },
+          bar: {
+            type: 'string',
+            default: '.foo'
+          },
+          baz1: {
+            type: 'array',
+            items: {
+              type: 'string',
+              default: '.foo'
+            }
+          },
+          baz2: {
+            type: 'array',
+            items: {
+              properties: {
+                foo: {
+                  type: 'string',
+                  default: '.'
+                },
+                bar: {
+                  type: 'string',
+                  default: '.foo'
+                }
+              }
+            }
+          }
+        }
+      },
+      output: {
+        properties: {
+          bar: {
+            type: 'string',
+            default: '.foo'
+          }
+        }
+      }
+    },
+    create: {
+      forward: 'transit',
+      query: false
+    }
+  }
+}
+
+const target = {
+  entity: {
+    schema: {
+      properties: {
+        foo: {
+          type: 'string'
+        },
+        bar: {
+          type: 'string'
+        }
+      }
+    }
+  },
+  operations: {
+    transit: {
+      input: {
+        properties: {
+          foo: {
+            type: 'string'
+          },
+          bar: {
+            type: 'string'
+          },
+          baz1: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          baz2: {
+            type: 'array',
+            items: {
+              properties: {
+                foo: {
+                  type: 'string'
+                },
+                bar: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        }
+      },
+      output: {
+        properties: {
+          bar: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    create: {
+      forward: 'transit',
+      query: false,
+      input: {
+        properties: {
+          foo: {
+            type: 'string'
+          },
+          bar: {
+            type: 'string'
+          },
+          baz1: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          baz2: {
+            type: 'array',
+            items: {
+              properties: {
+                foo: {
+                  type: 'string'
+                },
+                bar: {
+                  type: 'string'
+                }
+              }
+            }
+          }
+        }
+      },
+      output: {
+        properties: {
+          bar: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+exports.source = source
+exports.target = target

package/test/component/dereference.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const { dereference } = require('../../src/.component')
+const fixtures = require('./dereference.fixtures')
+
+let source
+
+beforeEach(() => {
+  source = clone(fixtures.source)
+})
+
+it('should dereference', () => {
+  dereference(source)
+
+  expect(source).toStrictEqual(fixtures.target)
+})
+
+it('should throw on invalid schema reference', () => {
+  source.operations.transit.output.properties.baz = { type: 'string', default: '.' }
+  expect(() => dereference(source)).toThrow(/is not defined/)
+
+  source.operations.transit.output.properties.baz = { type: 'string', default: '.baz' }
+  expect(() => dereference(source)).toThrow(/is not defined/)
+})
+
+it('should throw on invalid forwarding', () => {
+  source.operations.create.forward = 'foo'
+  expect(() => dereference(source)).toThrow(/is not defined/)
+})

package/test/component/dummies/extension/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const manifest = (declaration) => {
+  if (declaration.ok !== true) return
+
+  return declaration
+}
+
+exports.manifest = manifest

package/test/component/dummies/extension/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "norm-dummy-extension",
+  "version": "1.0.0",
+  "private": true
+}