@toa.io/norm 1.0.0-alpha.29 → 1.0.0-alpha.292

package/test/context/normalize.fixtures.js

@@ -1,15 +1,12 @@
-'use strict'
+import { generate } from 'randomstring'
 
-const { generate } = require('randomstring')
-
-const context = {
+export const context = {
   runtime: {
     version: '0.0.0'
   },
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
-  packages: 'namespaces/**/*',
   registry: 'localhost:5000',
   compositions: [
     {
@@ -28,5 +25,3 @@ const context = {
     }
   }
 }
-
-exports.context = context

package/test/context/normalize.test.js

@@ -1,10 +1,12 @@
-'use strict'
+import * as definitions from '@toa.io/definitions'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
 
-const fixtures = require('./normalize.fixtures')
-const { normalize } = require('../../src/.context')
+import * as fixtures from './normalize.fixtures.js'
+import { normalize } from '../../src/.context/index.js'
 
 let context
 
@@ -17,8 +19,8 @@ it('should resolve local version', () => {
 
   normalize(context)
 
-  expect(context.runtime).not.toEqual('.')
-  expect(context.runtime.version).toEqual(require('@toa.io/runtime').version)
+  assert.notDeepStrictEqual(context.runtime, '.')
+  assert.deepStrictEqual(context.runtime.version, definitions.version)
 })
 
 it('should expand registry', () => {
@@ -28,7 +30,29 @@ it('should expand registry', () => {
 
   normalize(context)
 
-  expect(context.registry).toEqual({
-    base
+  assert.deepStrictEqual(context.registry, {
+    base,
+    platforms: ['linux/amd64', 'linux/arm/v7', 'linux/arm64']
   })
 })
+
+it('should set default platforms', () => {
+  context.registry = { base: generate() }
+
+  normalize(context)
+
+  assert.deepStrictEqual(context.registry.platforms, [
+    'linux/amd64',
+    'linux/arm/v7',
+    'linux/arm64'
+  ])
+})
+
+it('should keep platforms declared as none', () => {
+  // `platforms: ~` in the context: the runner's own platform, not the default list
+  context.registry = { base: generate(), platforms: null }
+
+  normalize(context)
+
+  assert.strictEqual(context.registry.platforms, null)
+})

package/test/context/validate.fixtures.js

@@ -1,13 +1,10 @@
-'use strict'
-
-const context = {
+export const context = {
   runtime: {
     version: '0.0.0'
   },
   name: 'test',
   description: 'context fixture',
   version: '0.0.0',
-  packages: 'namespaces/**/*',
   build: {
     command: 'echo test'
   },
@@ -37,5 +34,3 @@ const context = {
     }
   }
 }
-
-exports.context = context

package/test/context/validate.test.js

@@ -1,14 +1,15 @@
-'use strict'
+import { describe, it, before, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
+import clone from 'clone-deep'
 
-const { validate } = require('../../src/.context')
-const fixtures = require('./validate.fixtures')
+import { validate } from '../../src/.context/index.js'
+import * as fixtures from './validate.fixtures.js'
 
 let context
 
-beforeAll(() => {
-  expect(() => validate(fixtures.context)).not.toThrow()
+before(() => {
+  assert.doesNotThrow(() => validate(fixtures.context))
 })
 
 beforeEach(() => {
@@ -18,23 +19,32 @@ beforeEach(() => {
 describe('runtime', () => {
   it('should require', () => {
     delete context.runtime
-    expect(() => validate(context)).toThrow(/required/)
+    assert.throws(
+      () => validate(context),
+      (error) => /required/.test(error.message)
+    )
   })
 
   it('should require registry to match uri format', () => {
     context.runtime.registry = 'not-a-uri'
-    expect(() => validate(context)).toThrow(/must match format/)
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.registry = 'http://localhost'
-    expect(() => validate(context)).not.toThrow()
+    assert.doesNotThrow(() => validate(context))
   })
 
   it('should require proxy to match uri format', () => {
     context.runtime.proxy = 'not-a-uri'
-    expect(() => validate(context)).toThrow(/must match format/)
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.proxy = 'http://localhost'
-    expect(() => validate(context)).not.toThrow()
+    assert.doesNotThrow(() => validate(context))
   })
 })
 
@@ -42,43 +52,77 @@ describe('registry', () => {
   it('should require', () => {
     delete context.registry
 
-    expect(() => validate(context)).toThrow(/required property 'registry'/)
-  })
-
-  it('should require base', () => {
-    delete context.registry.base
-
-    expect(() => validate(context)).toThrow(/required property 'base'/)
-  })
-
-  it('should set default platforms', () => {
-    delete context.registry.platforms
-
-    validate(context)
-
-    expect(context.registry.platforms).toBeInstanceOf(Array)
-    expect(context.registry.platforms).toStrictEqual(['linux/amd64', 'linux/arm/v7', 'linux/arm64'])
+    assert.throws(
+      () => validate(context),
+      (error) => /required property 'registry'/.test(error.message)
+    )
   })
 })
 
 it('should require name as label', () => {
   delete context.name
-  expect(() => validate(context)).toThrow(/required/)
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
 
   context.name = 'foo bar'
-  expect(() => validate(context)).toThrow(/pattern/)
+  assert.throws(
+    () => validate(context),
+    (error) => /pattern/.test(error.message)
+  )
 
   context.name = 'foo-bar'
-  expect(() => validate(context)).not.toThrow(/pattern/)
-})
-
-it('should set default packages location', () => {
-  delete context.packages
-  expect(() => validate(context)).not.toThrow()
-  expect(context.packages).toBe('components/*')
+  assert.doesNotThrow(() => validate(context))
 })
 
 it('should require registry url', () => {
   delete context.registry
-  expect(() => validate(context)).toThrow(/required/)
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
+})
+
+it('should allow mono replicas and resources', () => {
+  context.mono = {
+    replicas: 2,
+    resources: {
+      cpu: ['200m', '2'],
+      memory: ['256Mi', '2Gi']
+    }
+  }
+
+  assert.doesNotThrow(() => validate(context))
+})
+
+describe('compositions', () => {
+  it('should allow services', () => {
+    context.compositions[0].services = ['@toa.io/extensions.exposition']
+
+    assert.doesNotThrow(() => validate(context))
+  })
+
+  it('should require services to be a non-empty array of strings', () => {
+    context.compositions[0].services = []
+    assert.throws(
+      () => validate(context),
+      (error) => /fewer than 1 items/.test(error.message)
+    )
+
+    context.compositions[0].services = 'exposition'
+    assert.throws(
+      () => validate(context),
+      (error) => /must be array/.test(error.message)
+    )
+  })
+
+  it('should reject an unknown property', () => {
+    context.compositions[0].compoments = ['a.b']
+
+    assert.throws(
+      () => validate(context),
+      (error) => /Property compoments is not expected to be here/.test(error.message)
+    )
+  })
 })

package/test/definition.test.js

@@ -0,0 +1,35 @@
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+import { join } from 'node:path'
+
+import { definition } from '../src/definition.js'
+
+it('reads a definition.js where a package ships one', async () => {
+  const { name, module } = await definition(join(import.meta.dirname, 'dummies/defined'))
+
+  assert.equal(name, 'dummies.defined')
+  assert.equal(module.declares, true)
+  assert.equal(module.runs, undefined)
+})
+
+it('reads the entry where a package ships no definition.js', async () => {
+  const path = join(import.meta.dirname, '../')
+  const { name, module } = await definition(path)
+
+  assert.equal(name, '@toa.io/norm')
+  assert.ok(module.context instanceof Function)
+})
+
+it('names a directory without package.json by its reference', async () => {
+  const path = join(import.meta.dirname, 'dummies/bare')
+  const { name, module } = await definition(path)
+
+  assert.equal(name, path)
+  assert.equal(module.declares, true)
+})
+
+it('loads a definition once', async () => {
+  const path = join(import.meta.dirname, 'dummies/bare')
+
+  assert.equal(await definition(path), await definition(path))
+})

package/test/dummies/bare/index.js

@@ -0,0 +1 @@
+export const declares = true

package/test/dummies/defined/definition.js

@@ -0,0 +1 @@
+export const declares = true

package/test/dummies/defined/index.js

@@ -0,0 +1 @@
+export const runs = true

package/test/dummies/defined/package.json

@@ -0,0 +1 @@
+{ "name": "dummies.defined", "type": "module", "main": "index.js" }

package/test/shortcuts.fixtures.js

@@ -1,14 +1,9 @@
-'use strict'
+import { generate } from 'randomstring'
+import { random } from '@toa.io/generic'
 
-const { generate } = require('randomstring')
-const { random } = require('@toa.io/generic')
-
-const SHORTCUTS = {
+export const SHORTCUTS = {
   amqp: '@toa.io/bindings.amqp',
   mongodb: '@toa.io/storages.mongodb'
 }
 
-const object = { foo: random(), bar: { baz: generate() } }
-
-exports.object = object
-exports.SHORTCUTS = SHORTCUTS
+export const object = { foo: random(), bar: { baz: generate() } }

package/test/shortcuts.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
 
-const { recognize, resolve } = require('../src/shortcuts')
-const fixtures = require('./shortcuts.fixtures')
+import { recognize, resolve } from '../src/shortcuts.js'
+import * as fixtures from './shortcuts.fixtures.js'
 
 let object
 
@@ -14,16 +15,16 @@ beforeEach(() => {
 
 describe('resolve', () => {
   it('should be defined', () => {
-    expect(resolve).toBeDefined()
+    assert.notStrictEqual(resolve, undefined)
   })
 
   it('should resolve', () => {
-    expect(Object.keys(fixtures.SHORTCUTS).length).toBeGreaterThan(0)
+    assert.ok(Object.keys(fixtures.SHORTCUTS).length > 0)
 
     for (const [key, value] of Object.entries(fixtures.SHORTCUTS)) {
       const resolved = resolve(key)
 
-      expect(resolved).toStrictEqual(value)
+      assert.deepStrictEqual(resolved, value)
     }
   })
 })
@@ -32,7 +33,7 @@ describe('recognize', () => {
   it('should not change unknown', () => {
     recognize(fixtures.SHORTCUTS, object)
 
-    expect(object).toStrictEqual(fixtures.object)
+    assert.deepStrictEqual(object, fixtures.object)
   })
 
   it('should resolve known', () => {
@@ -41,8 +42,8 @@ describe('recognize', () => {
     recognize(fixtures.SHORTCUTS, object)
 
     for (const [alias, name] of Object.entries(fixtures.SHORTCUTS)) {
-      expect(object[alias]).toBeUndefined()
-      expect(object[name]).toStrictEqual(known[name])
+      assert.strictEqual(object[alias], undefined)
+      assert.deepStrictEqual(object[name], known[name])
     }
   })
 
@@ -52,9 +53,10 @@ describe('recognize', () => {
 
     recognize(fixtures.SHORTCUTS, object, group)
 
-    expect(object[group]).toStrictEqual(known)
+    assert.deepStrictEqual(object[group], known)
 
-    for (const alias of Object.keys(fixtures.SHORTCUTS)) expect(object[alias]).toBeUndefined()
+    for (const alias of Object.keys(fixtures.SHORTCUTS))
+      assert.strictEqual(object[alias], undefined)
   })
 
   it('should not overwrite group', () => {
@@ -67,7 +69,7 @@ describe('recognize', () => {
 
     recognize(fixtures.SHORTCUTS, object, group)
 
-    expect(object[group]).toStrictEqual(expect.objectContaining(existing))
+    assert.partialDeepStrictEqual(object[group], existing)
   })
 
   it('should not create empty group', () => {
@@ -75,7 +77,7 @@ describe('recognize', () => {
 
     recognize(object, group)
 
-    expect(object[group]).toBeUndefined()
+    assert.strictEqual(object[group], undefined)
   })
 
   const append = () => {

package/types/component.d.ts

@@ -1,4 +1,5 @@
-import type { Locator, operations } from '@toa.io/core'
+import type { Locator } from '@toa.io/core'
+import type { operations } from '@toa.io/core/types'
 
 type Map = {
   [id: string]: Component
@@ -8,6 +9,7 @@ export type Operation = {
   type: operations.type
   scope?: operations.scope
   bindings?: string[]
+  description?: string
   input?: any
   output?: any
   error?: any
@@ -34,10 +36,22 @@ type Receiver = {
   source?: string
 }
 
-type Entity = {
-  schema: Object
+type Migration = {
+  id: string
+  steps: unknown[]
+  /** the prototype it is inherited from; absent on the component's own */
+  prototype?: string
+}
+
+export type Entity = {
+  properties: Record<string, Object>
+  required?: string[]
+  /** what a record holds before anything is written to it */
+  blank?: Record<string, unknown>
   storage?: string
   associated?: boolean
+  custom?: boolean
+  migrations?: Migration[]
 }
 
 type Declaration = {

package/types/context/declaration.d.ts

@@ -1,8 +1,30 @@
-import { Composition, Registry, Runtime } from '../context'
+import { Registry, Runtime } from '../context.js'
 
+/** A composition as declared, before its members are resolved. */
 interface Composition {
-  name: string,
+  name: string
   components: string[]
+  services?: string[]
+}
+
+export interface Resources {
+  cpu?: [string, string]
+  memory?: [string, string]
+}
+
+export interface Mono {
+  replicas?: number
+  resources?: Resources
+}
+
+/**
+ * Cluster-level ingress configuration, applied to every service that declares one.
+ */
+export interface Ingress {
+  hosts?: string[]
+  class?: string
+  annotations?: Record<string, string>
+  default?: boolean
 }
 
 export interface Declaration {
@@ -11,7 +33,8 @@ export interface Declaration {
   version?: string
   runtime?: Runtime | string
   registry?: Registry | string
-  packages?: string
   compositions?: Composition[]
+  mono?: Mono
+  ingress?: Ingress
   annotations?: Record<string, object>
 }

package/types/context.d.ts

@@ -1,41 +1,43 @@
-import { Manifest } from './component'
+import { Manifest } from './component.js'
 import { Locator } from '@toa.io/core'
-import type { Declaration } from './context/declaration'
+import type { Declaration } from './context/declaration.js'
 
-interface Runtime{
+interface Runtime {
   version: string
   registry?: string
   proxy?: string
 }
 
-interface Registry{
+interface Registry {
   base?: string
   platforms?: string[] | null
+  services?: 'build' | 'published'
   build?: {
     arguments?: string[]
     run?: string
-  },
+  }
   credentials: string
 }
 
-interface Composition{
-  name: string,
-  components: _component.Component[]
+interface Composition {
+  name: string
+  components: Manifest[]
+  services?: string[]
 }
 
-export interface Dependency<T = undefined>{
+export interface Dependency<T = undefined> {
   locator: Locator
-  manifest: T,
+  manifest: T
   component: Manifest
 }
 
-interface Context extends Declaration{
+interface Context extends Declaration {
   runtime?: Runtime
   environment?: string
   registry?: Registry
   compositions?: Composition[]
-  components?: _component.Component[]
+  components?: Manifest[]
   dependencies?: Record<string, Dependency[]>
 }
 
-export function context (path: string, environment?: string): Promise<Context>
+export function context(path: string, environment?: string): Promise<Context>

package/types/entity.d.ts

@@ -0,0 +1,7 @@
+import type { Entity } from './component.js'
+
+/** The schema a stored record must fit. */
+export function schema(entity: Entity): object
+
+/** The schema a changeset must fit: the same properties, none of them required. */
+export function changeset(entity: Entity): object

package/types/index.d.ts

@@ -1,4 +1,13 @@
-export * as context from './context'
-export * as component from './component'
+export * as context from './context.js'
+export * as component from './component.js'
 
-export { Manifest } from './component'
+export { Manifest } from './component.js'
+export * as entity from './entity.js'
+
+export interface Definition {
+  /** The package's name, or the reference where it has no package.json */
+  name: string
+  module: Record<string, any>
+}
+
+export function definition(reference: string): Promise<Definition>

package/src/.context/.dependencies/load.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-
-/**
- * @param {string} path
- * @returns {{ metadata: object, module: object }}
- */
-function load (path) {
-  const metadata = loadMetadata(path)
-  const module = loadModule(path)
-
-  return { metadata, module }
-}
-
-function loadMetadata (reference) {
-  reference = join(reference, 'package.json')
-
-  try {
-    return require(reference)
-  } catch {
-    return null
-  }
-}
-
-/**
- * @param {string} reference
- * @returns {object}
- */
-function loadModule (reference) {
-  const path = require.resolve(reference)
-
-  return require(path)
-}
-
-exports.load = load

package/test/context/dependencies.load.test.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-const { load } = require('../../src/.context/.dependencies/load')
-
-it('should be', async () => {
-  expect(load).toBeInstanceOf(Function)
-})
-
-it('should load module', async () => {
-  const path = join(__dirname, '../../')
-  const { metadata, module } = load(path)
-
-  expect(metadata.name).toStrictEqual('@toa.io/norm')
-  expect(module.context).toBeInstanceOf(Function)
-})
-
-it('should return null metadata if no package.json', async () => {
-  const path = join(__dirname, '../../src')
-  const { metadata, module } = load(path)
-
-  expect(metadata).toBeNull()
-  expect(module.context).toBeInstanceOf(Function)
-})