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

package/src/deployment/images/image.js

@@ -1,23 +1,15 @@
-'use strict'
+import { join, posix } from 'node:path'
+import { readFile as read, writeFile as write } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
 
-const {
-  join,
-  posix
-} = require('node:path')
-const {
-  readFile: read,
-  writeFile: write
-} = require('node:fs/promises')
-const { createHash } = require('node:crypto')
-
-const { overwrite } = require('@toa.io/generic')
-const { mkdir } = require('node:fs/promises')
+import { overwrite } from '@toa.io/generic'
+import { mkdir } from 'node:fs/promises'
 
 /**
  * @implements {toa.deployment.images.Image}
  * @abstract
  */
-class Image {
+export class Image {
   context
   reference
   dockerfile
@@ -26,9 +18,7 @@ class Image {
   #registry
   #runtime
   #values = {
-    build: {
-      image: 'node:20.9.0-alpine3.18'
-    }
+    build: {}
   }
 
   constructor (scope, runtime, registry) {
@@ -54,6 +44,8 @@ class Image {
 
   get base () {}
 
+  get run () {}
+
   async prepare (root) {
     if (this.dockerfile === undefined) throw new Error('Dockerfile isn\'t specified')
 
@@ -65,7 +57,7 @@ class Image {
 
     const template = await read(this.dockerfile, 'utf-8')
     const contents = template.replace(/{{(\S{1,32})}}/g, (_, key) => this.#value(key))
-    const ignore = 'Dockerfile'
+    const ignore = ['Dockerfile', '**/node_modules'].join('\r\n')
 
     await write(join(path, 'Dockerfile'), contents)
     await write(join(path, '.dockerignore'), ignore)
@@ -77,13 +69,19 @@ class Image {
 
   #setValues () {
     this.#values.runtime = this.#runtime
-    this.#values.build = overwrite(this.#values.build, this.#registry.build)
+    this.#values.build = overwrite({
+      image: `${RUNTIME_IMAGE}:${this.#runtime.version}`
+    }, this.#registry.build)
 
     const image = this.base
 
-    if (image !== undefined) {
+    if (image !== undefined)
       this.#values.build.image = image
-    }
+
+    const run = this.run
+
+    if (run !== undefined)
+      this.#values.build.run = (this.#values.build.run === undefined ? '' : this.#values.build.run + '\n') + run
 
     if (this.#values.build.arguments !== undefined) this.#values.build.arguments = createArguments(this.#values.build.arguments)
     if (this.#values.build.run !== undefined) this.#values.build.run = createRunCommands(this.#values.build.run)
@@ -121,4 +119,4 @@ function createArguments (variables) {
   return args.join('\n')
 }
 
-exports.Image = Image
+export const RUNTIME_IMAGE = 'ghcr.io/toa-io/runtime'

package/src/deployment/images/image.test.js

@@ -1,7 +1,8 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const fixtures = require('./image.fixtures')
-const { generate } = require('randomstring')
+import * as fixtures from './image.fixtures.js'
+import { generate } from 'randomstring'
 
 /** @type {toa.deployment.images.Image} */
 let instance
@@ -13,11 +14,11 @@ beforeEach(() => {
 it('should assign url', () => {
   instance.tag()
 
-  expect(instance.reference).toEqual(`${fixtures.registry.base}/${fixtures.scope}/${fixtures.name}:${fixtures.version}`)
+  assert.deepStrictEqual(instance.reference, `${fixtures.registry.base}/${fixtures.scope}/${fixtures.name}:${fixtures.version}`)
 })
 
 describe('prepare', () => {
   it('should throw error if no dockerfile specified', async () => {
-    await expect(instance.prepare(generate())).rejects.toThrow(/Dockerfile isn't specified/)
+    await assert.rejects(instance.prepare(generate()), (error) => /Dockerfile isn't specified/.test(error.message))
   })
 })

package/src/deployment/images/index.js

@@ -1,5 +1 @@
-'use strict'
-
-const { Factory } = require('./factory')
-
-exports.Factory = Factory
+export { Factory } from './factory.js'

package/src/deployment/images/mono.Dockerfile

@@ -0,0 +1,18 @@
+FROM {{build.image}}
+
+{{build.arguments}}
+
+ENV NODE_ENV=production
+RUN if [ "{{runtime.registry}}" != "" ]; then npm set registry {{runtime.registry}}; fi
+RUN if [ "{{runtime.proxy}}" != "" ]; then npm set proxy {{runtime.proxy}}; fi
+
+WORKDIR /composition
+COPY --chown=node:node . /composition
+
+{{build.run}}
+
+RUN --mount=type=cache,target=/root/.npm \
+  for entry in *; do if grep -qs '"dependencies"' "$entry/package.json"; then (cd $entry && npm i --omit=dev); fi; done
+
+USER node
+CMD toa mono *

package/src/deployment/images/mono.js

@@ -0,0 +1,72 @@
+import { join } from 'node:path'
+import fs from 'fs-extra'
+import { createHash } from 'node:crypto'
+
+import { Image } from './image.js'
+import { declare } from './format.js'
+
+export class Mono extends Image {
+  dockerfile = join(import.meta.dirname, 'mono.Dockerfile')
+
+  #image
+  #components
+
+  constructor (scope, runtime, registry, composition) {
+    super(scope, runtime, registry)
+
+    this.#image = composition.image
+    this.#components = composition.components
+  }
+
+  get name () {
+    return 'mono'
+  }
+
+  get version () {
+    const hash = createHash('sha256')
+
+    for (const component of this.#components) {
+      hash.update(component.locator.id)
+      hash.update(component.version)
+    }
+
+    return hash.digest('hex').slice(0, 8)
+  }
+
+  get base () {
+    if (this.#image !== undefined) return this.#image
+
+    const images = new Set(this.#components.map((component) => component.build?.image))
+
+    if (images.size > 1)
+      throw new Error('Mono deployment requires different base images for its components. Specify base image for the composition in the context.')
+
+    return images.values().next().value
+  }
+
+  get run () {
+    const commands = []
+
+    for (const component of this.#components) {
+      const run = component.build?.run
+
+      if (run !== undefined)
+        commands.push(run)
+    }
+
+    return commands.join('\n')
+  }
+
+  async prepare (root) {
+    const context = await super.prepare(root)
+
+    for (const component of this.#components) {
+      const target = join(context, component.locator.label)
+
+      await fs.copy(component.path, target)
+      await declare(component.path, target, component.locator.label)
+    }
+
+    return context
+  }
+}

package/src/deployment/images/runtime-base.test.js

@@ -0,0 +1,91 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { join } from 'node:path'
+import { mkdtemp, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+
+import { Image, RUNTIME_IMAGE } from './image.js'
+
+const compositionDockerfile = join(import.meta.dirname, 'composition.Dockerfile')
+const serviceDockerfile = join(import.meta.dirname, 'service.Dockerfile')
+
+class TestImage extends Image {
+  dockerfile
+
+  #name
+  #base
+
+  constructor (runtime, registry, dockerfile, name = 'test', base) {
+    super('acme', runtime, registry)
+
+    this.dockerfile = dockerfile
+    this.#name = name
+    this.#base = base
+  }
+
+  get name () {
+    return this.#name
+  }
+
+  get version () {
+    return 'abcdef12'
+  }
+
+  get base () {
+    return this.#base
+  }
+}
+
+describe('runtime base image', () => {
+  /** @type {string} */
+  let root
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'toa-runtime-base-test'))
+  })
+
+  it('should default build.image to version-pinned GHCR runtime image', async () => {
+    const runtime = { version: '1.0.0-alpha.232' }
+    const image = new TestImage(runtime, {}, compositionDockerfile)
+
+    const path = await image.prepare(root)
+    const dockerfile = await readFile(join(path, 'Dockerfile'), 'utf8')
+
+    assert.ok(dockerfile.includes(`FROM ${RUNTIME_IMAGE}:1.0.0-alpha.232`))
+    assert.doesNotMatch(dockerfile, /npm i -g @toa\.io\/runtime/)
+  })
+
+  it('should not install runtime in service Dockerfile template', async () => {
+    const runtime = { version: '1.0.0-alpha.99' }
+    const image = new TestImage(runtime, {}, serviceDockerfile, 'service-test')
+
+    const path = await image.prepare(root)
+    const dockerfile = await readFile(join(path, 'Dockerfile'), 'utf8')
+
+    assert.ok(dockerfile.includes(`FROM ${RUNTIME_IMAGE}:1.0.0-alpha.99`))
+    assert.doesNotMatch(dockerfile, /npm i -g @toa\.io\/runtime/)
+  })
+
+  it('should allow registry.build.image override', async () => {
+    const runtime = { version: '1.0.0-alpha.232' }
+    const registry = { build: { image: 'node:24.14.0-alpine3.22' } }
+    const image = new TestImage(runtime, registry, compositionDockerfile)
+
+    const path = await image.prepare(root)
+    const dockerfile = await readFile(join(path, 'Dockerfile'), 'utf8')
+
+    assert.ok(dockerfile.includes('FROM node:24.14.0-alpine3.22'))
+    assert.ok(!(dockerfile.includes(RUNTIME_IMAGE)))
+  })
+
+  it('should allow composition.image override via base', async () => {
+    const runtime = { version: '1.0.0-alpha.232' }
+    const image = new TestImage(runtime, {}, compositionDockerfile, 'mono', 'custom.example/base:1')
+
+    const path = await image.prepare(root)
+    const dockerfile = await readFile(join(path, 'Dockerfile'), 'utf8')
+
+    assert.ok(dockerfile.includes('FROM custom.example/base:1'))
+  })
+})

package/src/deployment/images/service.Dockerfile

@@ -1,14 +1,14 @@
-FROM node:20.9.0-alpine3.18
+FROM {{build.image}}
 
 ENV NODE_ENV=production
 RUN if [ "{{runtime.registry}}" != "" ]; then npm set registry {{runtime.registry}}; fi
 RUN if [ "{{runtime.proxy}}" != "" ]; then npm set proxy {{runtime.proxy}}; fi
-RUN npm i -g @toa.io/runtime@{{runtime.version}} --omit=dev
 
 WORKDIR /service
 COPY --chown=node:node . /service
 
-RUN npm i --omit=dev
+RUN --mount=type=cache,target=/root/.npm \
+  npm i --omit=dev
 
 USER node
 CMD toa serve .

package/src/deployment/images/service.js

@@ -1,12 +1,14 @@
-'use strict'
+import { createRequire } from 'node:module'
+import { join, dirname } from 'node:path'
 
-const { join, dirname } = require('node:path')
+import { Image } from './image.js'
+import fs from 'fs-extra'
 
-const { Image } = require('./image')
-const fs = require('fs-extra')
+// a service is named the way a package is, and its directory is where it lives
+const require = createRequire(import.meta.url)
 
-class Service extends Image {
-  dockerfile = join(__dirname, 'service.Dockerfile')
+export class Service extends Image {
+  dockerfile = join(import.meta.dirname, 'service.Dockerfile')
 
   /**
    * Used by Dockerfile
@@ -70,5 +72,3 @@ class Service extends Image {
 const find = (reference) => {
   return dirname(require.resolve(join(reference, 'package.json')))
 }
-
-exports.Service = Service

package/src/deployment/index.js

@@ -1,5 +1 @@
-'use strict'
-
-const { Factory } = require('./factory')
-
-exports.Factory = Factory
+export { Factory } from './factory.js'

package/src/deployment/operator.js

@@ -1,8 +1,6 @@
-'use strict'
+import * as workspace from './workspace.js'
 
-const workspace = require('./workspace')
-
-class Operator {
+export class Operator {
   /** @type {toa.deployment.Deployment} */
   #deployment
 
@@ -50,9 +48,11 @@ class Operator {
   variables () {
     return this.#deployment.variables()
   }
+
+  tags () {
+    return this.#registry.tags()
+  }
 }
 
 /** @type {toa.deployment.installation.Options} */
 const OPTIONS = { wait: false }
-
-exports.Operator = Operator

package/src/deployment/operator.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { Operator } = require('../../src/deployment/operator')
-const { generate } = require('randomstring')
+import { Operator } from '../../src/deployment/operator.js'
+import { generate } from 'randomstring'
 
 it('should be', async () => {
-  expect(Operator).toBeInstanceOf(Function)
+  assert.ok(Operator instanceof Function)
 })
 
 /** @type {toa.deployment.Operator} */
@@ -25,7 +26,7 @@ describe('env', () => {
   it('should be', async () => {
     operator = new Operator(deployment, registry)
 
-    expect(operator.variables).toBeInstanceOf(Function)
+    assert.ok(operator.variables instanceof Function)
   })
 
   it('should return variables', async () => {
@@ -33,12 +34,12 @@ describe('env', () => {
 
     deployment.variables =
       /** @type {typeof toa.deployment.Operator.variables} */
-      jest.fn(() => variables)
+      mock.fn(() => variables)
 
     operator = new Operator(deployment, registry)
 
     const output = operator.variables()
 
-    expect(output).toStrictEqual(variables)
+    assert.deepStrictEqual(output, variables)
   })
 })

package/src/deployment/registry.js

@@ -1,12 +1,12 @@
-'use strict'
-
-const workspace = require('./workspace')
-const { newid } = require('@toa.io/generic')
+import { posix } from 'node:path'
+import * as workspace from './workspace.js'
 
 /**
  * @implements {toa.deployment.Registry}
  */
-class Registry {
+export class Registry {
+  #scope
+
   #registry
 
   #factory
@@ -15,7 +15,11 @@ class Registry {
 
   #images = []
 
-  constructor (registry, factory, process) {
+  /** @type {string | undefined} */
+  #builder
+
+  constructor (scope, registry, factory, process) {
+    this.#scope = scope
     this.#registry = registry
     this.#factory = factory
     this.#process = process
@@ -29,6 +33,10 @@ class Registry {
     return this.#create('service', path, service)
   }
 
+  mono (composition) {
+    return this.#create('mono', composition)
+  }
+
   async prepare (root) {
     const path = await workspace.create('images', root)
 
@@ -40,9 +48,8 @@ class Registry {
   async build () {
     await this.prepare()
 
-    for (const image of this.#images) {
+    for (const image of this.#images)
       await this.#build(image)
-    }
   }
 
   async push () {
@@ -51,8 +58,12 @@ class Registry {
     for (const image of this.#images) await this.#push(image)
   }
 
+  tags () {
+    return this.#images.map((image) => image.reference)
+  }
+
   /**
-   * @param {'composition' | 'service'} type
+   * @param {'composition' | 'service' | 'mono'} type
    * @param {...any} args
    * @returns {toa.deployment.images.Image}
    */
@@ -70,13 +81,17 @@ class Registry {
    * @returns {Promise<void>}
    */
   async #build (image, push = false) {
+    if (await this.exists(image.reference)) {
+      console.log('Image already exists, skipping:', image.reference)
+      return
+    }
+
     const args = ['--context=default', 'buildx', 'build']
 
-    if (push) {
+    if (push)
       args.push('--push')
-    } else {
+    else
       args.push('--load')
-    }
 
     args.push('--tag', image.reference, image.context)
 
@@ -88,14 +103,15 @@ class Registry {
 
     if (multiarch) {
       const platform = this.#registry.platforms.join(',')
-      const builder = await this.#createBuilder()
+      const builder = await this.#ensureBuilder()
 
       args.push('--platform', platform)
       args.push('--builder', builder)
 
-    } else {
+      if (this.#registry.base !== undefined)
+        this.#appendCache(args)
+    } else
       args.push('--builder', 'default')
-    }
 
     args.push('--progress', 'plain')
 
@@ -106,16 +122,44 @@ class Registry {
     await this.#build(image, true)
   }
 
-  async #createBuilder () {
-    const name = `toa-${newid()}`
-    const create = `buildx create --name ${name} --bootstrap --use`.split(' ')
+  async exists (tag) {
+    const args = ['manifest', 'inspect', tag]
+
+    try {
+      await this.#process.execute('docker', args, { silently: true })
+    } catch (error) {
+      console.log(error.message)
+
+      return false
+    }
+
+    return true
+  }
+
+  async #ensureBuilder () {
+    if (this.#builder !== undefined)
+      return this.#builder
+
+    try {
+      await this.#process.execute('docker', ['buildx', 'inspect', BUILDER], { silently: true })
+    } catch {
+      await this.#process.execute('docker', ['buildx', 'create', '--name', BUILDER, '--bootstrap'])
+    }
 
-    await this.#process.execute('docker', create)
+    this.#builder = BUILDER
 
-    return name
+    return BUILDER
+  }
+
+  /**
+   * @param {string[]} args
+   */
+  #appendCache (args) {
+    const ref = posix.join(this.#registry.base, this.#scope, 'buildcache')
+
+    args.push('--cache-from', `type=registry,ref=${ref}`)
+    args.push('--cache-to', `type=registry,ref=${ref},mode=max,image-manifest=true`)
   }
 }
 
 const BUILDER = 'toa'
-
-exports.Registry = Registry