@toa.io/operations 1.0.0-alpha.28 → 1.0.0-alpha.280

package/src/deployment/registry.test.js

@@ -0,0 +1,177 @@
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
+
+import { Registry } from './registry.js'
+
+/** @type {toa.operations.Process} */
+let process
+
+/** @type {toa.deployment.images.Factory} */
+let factory
+
+/** @type {toa.deployment.images.Image[]} */
+let images
+
+beforeEach(() => {
+  images = []
+  process = /** @type {toa.operations.Process} */ {
+    execute: mock.fn(async (cmd, args) => {
+      if (args[0] === 'manifest')
+        throw new Error('manifest unknown')
+
+      if (args[0] === 'buildx' && args[1] === 'inspect')
+        throw new Error('builder not found')
+
+      return ''
+    })
+  }
+
+  factory = /** @type {toa.deployment.images.Factory} */ {
+    composition: () => createImage('composition-mono'),
+    service: () => createImage('extension-realtime')
+  }
+})
+
+it('should reuse named builder across images', async () => {
+  const registry = createRegistry({ base: 'example.com/reg', platforms: ['linux/amd64'] })
+
+  registry.composition(/** @type {any} */ ({}))
+  registry.service('.', /** @type {any} */ ({}))
+
+  await registry.build()
+
+  const creates = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === 'buildx' && args[1] === 'create')
+
+  assert.strictEqual(creates.length, 1)
+  assert.deepStrictEqual(creates[0].arguments[1], ['buildx', 'create', '--name', 'toa', '--bootstrap'])
+
+  const builds = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === '--context=default' && args[1] === 'buildx' && args[2] === 'build')
+
+  assert.strictEqual(builds.length, 2)
+
+  for (const { arguments: [, args] } of builds) {
+    assert.ok(args.includes('--builder'))
+    assert.strictEqual(args[args.indexOf('--builder') + 1], 'toa')
+  }
+})
+
+it('should not create builder when it already exists', async () => {
+  process.execute = mock.fn(async (cmd, args) => {
+    if (args[0] === 'manifest')
+      throw new Error('manifest unknown')
+
+    return ''
+  })
+
+  const registry = createRegistry({ base: 'example.com/reg', platforms: ['linux/amd64'] })
+
+  registry.composition(/** @type {any} */ ({}))
+
+  await registry.build()
+
+  const creates = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === 'buildx' && args[1] === 'create')
+
+  assert.strictEqual(creates.length, 0)
+})
+
+it('should add shared registry cache flags when base is set', async () => {
+  const registry = createRegistry({ base: 'example.com/reg', platforms: ['linux/amd64'] })
+
+  registry.composition(/** @type {any} */ ({}))
+  registry.service('.', /** @type {any} */ ({}))
+
+  await registry.build()
+
+  const builds = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === '--context=default' && args[2] === 'build')
+
+  assert.strictEqual(builds.length, 2)
+
+  for (const { arguments: [, args] } of builds) {
+    assert.ok(args.includes('--cache-from'))
+    assert.ok(args.includes('type=registry,ref=example.com/reg/acme/buildcache'))
+    assert.ok(args.includes('--cache-to'))
+    assert.ok(args.includes('type=registry,ref=example.com/reg/acme/buildcache,mode=max,image-manifest=true'))
+  }
+})
+
+it('should omit cache flags when base is not set', async () => {
+  const registry = createRegistry({ platforms: ['linux/amd64'] })
+
+  registry.composition(/** @type {any} */ ({}))
+
+  await registry.build()
+
+  const builds = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === '--context=default' && args[2] === 'build')
+
+  assert.strictEqual(builds.length, 1)
+
+  const { arguments: [, args] } = builds[0]
+
+  assert.ok(!(args.includes('--cache-from')))
+  assert.ok(!(args.includes('--cache-to')))
+})
+
+it('should use default builder when platforms is null', async () => {
+  const registry = createRegistry({ base: 'example.com/reg', platforms: null })
+
+  registry.composition(/** @type {any} */ ({}))
+
+  await registry.build()
+
+  const builds = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === '--context=default' && args[2] === 'build')
+
+  assert.strictEqual(builds.length, 1)
+
+  const { arguments: [, args] } = builds[0]
+
+  assert.strictEqual(args[args.indexOf('--builder') + 1], 'default')
+  assert.ok(!(args.includes('--cache-from')))
+  assert.ok(!(args.includes('--platform')))
+})
+
+it('should skip build when image already exists', async () => {
+  process.execute = mock.fn(async () => '')
+
+  const registry = createRegistry({ base: 'example.com/reg', platforms: ['linux/amd64'] })
+
+  registry.composition(/** @type {any} */ ({}))
+
+  await registry.build()
+
+  const builds = process.execute.mock.calls.filter(({ arguments: [, args] }) =>
+    args[0] === '--context=default' && args[2] === 'build')
+
+  assert.strictEqual(builds.length, 0)
+  assert.ok(process.execute.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], 'docker') && isDeepStrictEqual(call.arguments[1], ['manifest', 'inspect', images[0].reference]) && isDeepStrictEqual(call.arguments[2], { silently: true })))
+})
+
+/**
+ * @param {object} [registry]
+ * @returns {Registry}
+ */
+function createRegistry (registry = {}) {
+  return new Registry('acme', registry, factory, process)
+}
+
+/**
+ * @param {string} name
+ * @returns {toa.deployment.images.Image}
+ */
+function createImage (name) {
+  const image = /** @type {toa.deployment.images.Image} */ {
+    reference: `example.com/reg/acme/${name}:abcdef12`,
+    context: `/tmp/${name}`,
+    prepare: mock.fn(async () => `/tmp/${name}`)
+  }
+
+  images.push(image)
+
+  return image
+}

package/src/deployment/service.js

@@ -1,6 +1,4 @@
-'use strict'
-
-class Service {
+export class Service {
   constructor (service, image) {
     Object.assign(this, service)
 
@@ -8,5 +6,3 @@ class Service {
     this.image = image.reference
   }
 }
-
-exports.Service = Service

package/src/deployment/workspace.js

@@ -1,17 +1,22 @@
-'use strict'
-
-const { directory } = require('@toa.io/filesystem')
+import { mkdir, mkdtemp, readdir } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+import { tmpdir } from 'node:os'
 
 /**
  * @param {string} type
  * @param {string} [path]
  * @return {Promise<string>}
  */
-async function create (type, path) {
-  if (path === undefined) path = await directory.temp('toa-' + type)
-  else path = await directory.ensure(path)
+export async function create (type, path) {
+  if (path === undefined) return await mkdtemp(join(tmpdir(), 'toa-' + type))
+
+  path = resolve(path)
+
+  await mkdir(path, { recursive: true })
+
+  const entries = await readdir(path)
+
+  if (entries.length > 0) throw new Error('Target directory must be empty')
 
   return path
 }
-
-exports.create = create

package/src/index.js

@@ -1,3 +1 @@
-'use strict'
-
-exports.deployment = require('./deployment')
+export * as deployment from './deployment/index.js'

package/src/process.js

@@ -1,15 +1,12 @@
-'use strict'
-
-const execa = require('execa')
+import { execa } from 'execa'
 
 /**
  * @implements {toa.operations.Process}
  */
-class Process {
+export class Process {
   async execute (cmd, args, options = {}) {
     console.log('toa>', cmd, args.join(' '))
 
-    /** @type {execa.ExecaReturnValue<import('stream').Stream>} */
     const command = execa(cmd, args)
 
     if (options.silently !== true) {
@@ -17,11 +14,8 @@ class Process {
       command.stderr.pipe(process.stderr)
     }
 
-    /** @type {execa.ExecaReturnValue<string>} */
     const result = await command
 
     return result.stdout
   }
 }
-
-exports.Process = Process

package/src/process.test.js

@@ -0,0 +1,20 @@
+import { it, describe } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Process } from './process.js'
+
+describe('execute', () => {
+  it('should answer what the command wrote', async () => {
+    // `execa` is a named export, and calling the module namespace instead answers
+    // `execa is not a function` — where only a deployment would have found out
+    const output = await new Process().execute('node', ['-e', 'process.stdout.write("ok")'],
+      { silently: true })
+
+    assert.strictEqual(output, 'ok')
+  })
+
+  it('should reject what the command failed at', async () => {
+    await assert.rejects(new Process().execute('node', ['-e', 'process.exit(1)'],
+      { silently: true }))
+  })
+})

package/types/_deployment/composition.d.ts

@@ -1,4 +1,4 @@
-import type * as _deployment from './deployment'
+import type * as _deployment from './deployment.js'
 
 declare namespace toa.deployment {
 

package/types/_deployment/dependency.d.ts

@@ -1,4 +1,4 @@
-import * as _service from './service'
+import * as _service from './service.js'
 import { dependencies } from '@toa.io/norm/types/context'
 
 declare namespace toa.deployment {
@@ -50,6 +50,7 @@ declare namespace toa.deployment {
       services?: Service[] // dependency.Service
       proxies?: Proxy[]
       variables?: Variables
+      events?: string[]
     }
 
   }
@@ -59,6 +60,7 @@ declare namespace toa.deployment {
     services?: _service.Service[] // deployment.Service
     proxies?: dependency.Proxy[]
     variables?: dependency.Variables
+    events?: string[]
   }
 
 }

package/types/_deployment/deployment.d.ts

@@ -1,6 +1,6 @@
-import type * as _composition from './composition'
-import type * as _service from './service'
-import type * as _dependency from './dependency'
+import type * as _composition from './composition.js'
+import type * as _service from './service.js'
+import type * as _dependency from './dependency.js'
 
 declare namespace toa.deployment {
 

package/types/_deployment/factory.d.ts

@@ -1,5 +1,5 @@
-import type * as _operator from './operator'
-import * as _registry from './registry'
+import type * as _operator from './operator.js'
+import * as _registry from './registry.js'
 
 declare namespace toa.deployment {
 

package/types/_deployment/images/factory.d.ts

@@ -1,8 +1,8 @@
 // noinspection ES6UnusedImports
 
 import type { Composition } from '@toa.io/norm/types'
-import type { Image } from './image'
-import type { dependency } from '../dependency'
+import type { Image } from './image.js'
+import type { dependency } from '../dependency.js'
 
 declare namespace toa.deployment.images {
 

package/types/_deployment/images/image.d.ts

@@ -4,9 +4,11 @@ declare namespace toa.deployment.images {
     readonly reference: string
     readonly context: string
 
-    tag(): void
+    name: string
 
-    prepare(root: string): Promise<string>
+    tag (): void
+
+    prepare (root: string): Promise<string>
   }
 
 }

package/types/_deployment/images/registry.d.ts

@@ -1,8 +1,8 @@
 // noinspection ES6UnusedImports
 
 import type { Composition } from '@toa.io/norm'
-import type { dependency } from '../dependency'
-import type { Image } from "./image"
+import type { dependency } from '../dependency.js'
+import type { Image } from "./image.js"
 
 declare namespace toa.deployment.images {
 

package/types/_deployment/operator.d.ts

@@ -1,5 +1,5 @@
-import * as _deployment from './deployment'
-import * as _dependency from './dependency'
+import * as _deployment from './deployment.js'
+import * as _dependency from './dependency.js'
 
 declare namespace toa.deployment {
 

package/types/_deployment/registry.d.ts

@@ -1,19 +1,21 @@
 import type * as _norm from '@toa.io/norm/types'
-import type * as _dependency from './dependency'
-import type * as _image from "./images/image"
+import type * as _dependency from './dependency.js'
+import type * as _image from './images/image.js'
 
 declare namespace toa.deployment {
-  
+
   interface Registry {
-    composition(composition: _norm.Composition): _image.Image
+    composition (composition: _norm.Composition): _image.Image
+
+    service (path: string, service: _dependency.Service): _image.Image
 
-    service(path: string, service: _dependency.Service): _image.Image
+    prepare (path: string): Promise<string>
 
-    prepare(path: string): Promise<string>
+    build (): Promise<void>
 
-    build(): Promise<void>
+    push (): Promise<void>
 
-    push(): Promise<void>
+    tags (): string[]
   }
 
 }

package/types/_deployment/service.d.ts

@@ -1,4 +1,4 @@
-import type * as _deployment from './deployment'
+import type * as _deployment from './deployment.js'
 
 declare namespace toa.deployment {
 
@@ -11,6 +11,9 @@ declare namespace toa.deployment {
   interface Service extends _deployment.Deployable {
     port: number
     ingress?: Ingress
+
+    /** Annotations for the Service itself, as opposed to `ingress.annotations`. */
+    annotations?: object
   }
 
 }

package/types/dependency.ts

@@ -0,0 +1,73 @@
+import type { Manifest } from '@toa.io/norm'
+import type { Locator } from '@toa.io/core'
+
+export interface Service {
+  group: string
+  name: string
+  version: string
+  port?: number
+  ingress?: Ingress
+  /** Annotations for the Service itself, as opposed to `ingress.annotations`. */
+  annotations?: object
+  resources?: Resources
+  variables?: Variable[]
+  components?: string[]
+  probe?: Probe | false
+}
+
+export interface Variable {
+  name: string
+  value?: string
+  secret?: {
+    name: string
+    key: string
+    optional?: boolean
+  }
+}
+
+export interface Instance<T> {
+  locator: Locator
+  manifest: T
+  component: Manifest
+}
+
+export type Instances<T> = Array<Instance<T>>
+
+export type Variables = Record<'global' | string, Variable[]>
+export type Mounts = Record<'global' | string, Mount[]>
+
+export interface Dependency {
+  services?: Service[]
+  variables?: Variables
+  mounts?: Mounts
+  /** Event labels (`namespace.name.event`) this dependency consumes. */
+  events?: string[]
+  /** Default probe for compositions and services without their own probe. `false` disables. */
+  probe?: Probe | false
+}
+
+interface Ingress {
+  /** Path prefix this service claims on the host. Defaults to `/`. */
+  path?: string
+  default?: boolean
+  hosts?: string[]
+  class?: string
+  annotations?: object
+}
+
+export interface Probe {
+  port: number
+  path: string
+  delay?: number
+}
+
+interface Mount {
+  name: string
+  path: string
+  claim: string
+}
+
+export interface Resources {
+  cpu: string[]
+  memory: string[]
+}

package/types/index.ts

@@ -0,0 +1 @@
+export * from './dependency.js'

package/types/dependency.d.ts

@@ -1,39 +0,0 @@
-export type Service = {
-  group: string
-  name: string
-  version: string
-  port: number
-  ingress: Ingress
-  variables: Variable[]
-  components?: string[]
-  probe?: Probe
-}
-
-export type Variable = {
-  name: string
-  value?: string
-  secret?: {
-    name: string,
-    key: string
-    optional?: boolean
-  }
-}
-
-export type Variables = Record<'global' | string, Variable[]>
-
-export type Dependency = {
-  services?: Service[]
-  variables?: Variables
-}
-
-type Ingress = {
-  hosts: string[]
-  class?: string
-  annotations?: object
-}
-
-interface Probe {
-  port: number
-  path: string
-  delay?: number
-}

package/types/index.d.ts

@@ -1 +0,0 @@
-export * from './dependency'