@toa.io/operations 1.0.0-alpha.284 → 1.0.0-alpha.287

package/src/deployment/images/image.js

@@ -21,13 +21,13 @@ export class Image {
     build: {}
   }
 
-  constructor (scope, runtime, registry) {
+  constructor(scope, runtime, registry) {
     this.#scope = scope
     this.#registry = registry
     this.#runtime = runtime
   }
 
-  tag () {
+  tag() {
     const hash = createHash('sha256')
 
     hash.update(this.#runtime.version)
@@ -35,25 +35,37 @@ export class Image {
 
     const tag = hash.digest('hex').slice(0, 8)
 
-    this.reference = posix.join(this.#registry.base ?? '', this.#scope, `${this.name}:${tag}`)
+    this.reference = posix.join(
+      this.#registry.base ?? '',
+      this.#scope,
+      `${this.name}:${tag}`
+    )
   }
 
   /** @returns {string | undefined} */
-  get name () { return undefined }
+  get name() {
+    return undefined
+  }
 
   /** @returns {string | undefined} */
-  get version () { return undefined }
+  get version() {
+    return undefined
+  }
 
   /** The image to build `FROM`. Undefined takes the runtime's, which is what a service does.
    *  @returns {string | undefined} */
-  get base () { return undefined }
+  get base() {
+    return undefined
+  }
 
   /** Build commands to add. Undefined adds none, which is what a service does.
    *  @returns {string | undefined} */
-  get run () { return undefined }
+  get run() {
+    return undefined
+  }
 
-  async prepare (root) {
-    if (this.dockerfile === undefined) throw new Error('Dockerfile isn\'t specified')
+  async prepare(root) {
+    if (this.dockerfile === undefined) throw new Error("Dockerfile isn't specified")
 
     this.#setValues()
 
@@ -73,38 +85,43 @@ export class Image {
     return path
   }
 
-  #setValues () {
+  #setValues() {
     this.#values.runtime = this.#runtime
-    this.#values.build = overwrite({
-      image: `${RUNTIME_IMAGE}:${this.#runtime.version}`
-    }, this.#registry.build)
+    this.#values.build = overwrite(
+      {
+        image: `${RUNTIME_IMAGE}:${this.#runtime.version}`
+      },
+      this.#registry.build
+    )
 
     const image = this.base
 
-    if (image !== undefined)
-      this.#values.build.image = image
+    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
+      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)
+    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)
   }
 
   /**
    * @param key {string}
    * @returns {string}
    */
-  #value (key) {
+  #value(key) {
     const [source, property] = key.split('.')
 
     return this.#values[source]?.[property] ?? ''
   }
 }
 
-function createRunCommands (input) {
+function createRunCommands(input) {
   const lines = input.split('\n')
 
   return lines.reduce((commands, command) => {
@@ -114,7 +131,7 @@ function createRunCommands (input) {
   }, '')
 }
 
-function createArguments (variables) {
+function createArguments(variables) {
   const args = []
 
   for (const variable of variables) {

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

@@ -14,11 +14,16 @@ beforeEach(() => {
 it('should assign url', () => {
   instance.tag()
 
-  assert.deepStrictEqual(instance.reference, `${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 assert.rejects(instance.prepare(generate()), (error) => /Dockerfile isn't specified/.test(error.message))
+    await assert.rejects(instance.prepare(generate()), (error) =>
+      /Dockerfile isn't specified/.test(error.message)
+    )
   })
 })

package/src/deployment/images/mono.Dockerfile

@@ -11,7 +11,7 @@ COPY --chown=node:node . /composition
 
 {{build.run}}
 
-RUN --mount=type=cache,target=/root/.npm \
+RUN --mount=type=cache,target=/root/.npm,sharing=locked \
   for entry in *; do if grep -qs '"dependencies"' "$entry/package.json"; then (cd $entry && npm i --omit=dev); fi; done
 
 USER node

package/src/deployment/images/mono.js

@@ -11,18 +11,18 @@ export class Mono extends Image {
   #image
   #components
 
-  constructor (scope, runtime, registry, composition) {
+  constructor(scope, runtime, registry, composition) {
     super(scope, runtime, registry)
 
     this.#image = composition.image
     this.#components = composition.components
   }
 
-  get name () {
+  get name() {
     return 'mono'
   }
 
-  get version () {
+  get version() {
     const hash = createHash('sha256')
 
     for (const component of this.#components) {
@@ -33,31 +33,32 @@ export class Mono extends Image {
     return hash.digest('hex').slice(0, 8)
   }
 
-  get base () {
+  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.')
+      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 () {
+  get run() {
     const commands = []
 
     for (const component of this.#components) {
       const run = component.build?.run
 
-      if (run !== undefined)
-        commands.push(run)
+      if (run !== undefined) commands.push(run)
     }
 
     return commands.join('\n')
   }
 
-  async prepare (root) {
+  async prepare(root) {
     const context = await super.prepare(root)
 
     for (const component of this.#components) {

package/src/deployment/images/publish.js

@@ -0,0 +1,98 @@
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { execa } from 'execa'
+
+import { Service } from './service.js'
+
+/**
+ * Builds and pushes the image an extension ships for its service, so that an application
+ * with `registry.services: published` takes it instead of building one.
+ *
+ * The image is built from the package as npm publishes it, not from the workspace: what
+ * `.npmignore` leaves out is not in the tarball, and an application builds from the tarball.
+ *
+ * @param {string} workspace path to the extension's directory in this repository
+ * @param {string} runtime the runtime version, which is the tag and the base image
+ * @param {string[]} platforms
+ * @returns {Promise<string>} the reference pushed
+ */
+export async function publish(workspace, runtime, platforms) {
+  const directory = resolve(workspace)
+  const manifest = read(join(directory, 'package.json'))
+
+  // read from the workspace, where the extension's own dependencies resolve; what is
+  // installed below carries the same constant but not everything it takes to load it
+  const { image } = await import(pathToFileURL(join(directory, manifest.main)).href)
+
+  if (image === undefined)
+    throw new Error(`'${manifest.name}' publishes no service image: it exports no 'image'`)
+
+  const root = await mkdtemp(join(tmpdir(), 'toa-publish'))
+
+  await writeFile(join(root, 'package.json'), '{"private":true}')
+  await run('npm', [
+    'i',
+    '--prefix',
+    root,
+    '--omit=dev',
+    `${manifest.name}@${manifest.version}`
+  ])
+
+  const path = join(root, 'node_modules', manifest.name)
+
+  const service = new Service(SCOPE, { version: runtime }, {}, path, {
+    ...name(image),
+    version: manifest.version
+  })
+
+  service.reference = `${image}:${runtime}`
+
+  await service.prepare(await mkdtemp(join(tmpdir(), 'toa-images')))
+
+  await run('docker', [
+    'buildx',
+    'build',
+    '--platform',
+    platforms.join(','),
+    '--tag',
+    service.reference,
+    '--provenance=false',
+    '--push',
+    service.context
+  ])
+
+  return service.reference
+}
+
+/** The repository's last segment is what `Service` names an image, so it reads back. */
+function name(image) {
+  const match = /\/extension-([^-/]+)-([^/]+)$/.exec(image)
+
+  if (match === null)
+    throw new Error(`'${image}' is not named 'extension-<group>-<name>'`)
+
+  return { group: match[1], name: match[2] }
+}
+
+const read = (path) => JSON.parse(readFileSync(path, 'utf8'))
+
+const run = async (cmd, args) => {
+  console.log('toa>', cmd, args.join(' '))
+
+  await execa(cmd, args, { stdio: 'inherit' })
+}
+
+// the reference is assigned rather than derived from a scope
+const SCOPE = ''
+
+const PLATFORMS = 'linux/amd64,linux/arm64'
+
+if (import.meta.main) {
+  const [workspace, runtime, platforms = PLATFORMS] = process.argv.slice(2)
+
+  console.log(await publish(workspace, runtime, platforms.split(',')))
+}

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

@@ -16,7 +16,7 @@ class TestImage extends Image {
   #name
   #base
 
-  constructor (runtime, registry, dockerfile, name = 'test', base) {
+  constructor(runtime, registry, dockerfile, name = 'test', base) {
     super('acme', runtime, registry)
 
     this.dockerfile = dockerfile
@@ -24,15 +24,15 @@ class TestImage extends Image {
     this.#base = base
   }
 
-  get name () {
+  get name() {
     return this.#name
   }
 
-  get version () {
+  get version() {
     return 'abcdef12'
   }
 
-  get base () {
+  get base() {
     return this.#base
   }
 }
@@ -76,12 +76,18 @@ describe('runtime base image', () => {
     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)))
+    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 image = new TestImage(
+      runtime,
+      {},
+      compositionDockerfile,
+      'mono',
+      'custom.example/base:1'
+    )
 
     const path = await image.prepare(root)
     const dockerfile = await readFile(join(path, 'Dockerfile'), 'utf8')

package/src/deployment/images/service.Dockerfile

@@ -7,7 +7,7 @@ RUN if [ "{{runtime.proxy}}" != "" ]; then npm set proxy {{runtime.proxy}}; fi
 WORKDIR /service
 COPY --chown=node:node . /service
 
-RUN --mount=type=cache,target=/root/.npm \
+RUN --mount=type=cache,target=/root/.npm,sharing=locked \
   npm i --omit=dev
 
 USER node

package/src/deployment/images/service.js

@@ -37,7 +37,7 @@ export class Service extends Image {
    * @param {string} reference
    * @param {toa.deployment.dependency.Service} service
    */
-  constructor (scope, runtime, registry, reference, service) {
+  constructor(scope, runtime, registry, reference, service) {
     super(scope, runtime, registry)
 
     this.service = service.name
@@ -48,15 +48,15 @@ export class Service extends Image {
     this.#version = service.version
   }
 
-  get name () {
+  get name() {
     return 'extension-' + this.#group + '-' + this.#name
   }
 
-  get version () {
+  get version() {
     return this.#version
   }
 
-  async prepare (root) {
+  async prepare(root) {
     const context = await super.prepare(root)
 
     await fs.copy(this.#path, context)

package/src/deployment/operator.js

@@ -11,12 +11,12 @@ export class Operator {
    * @param deployment {toa.deployment.Deployment}
    * @param registry {toa.deployment.Registry}
    */
-  constructor (deployment, registry) {
+  constructor(deployment, registry) {
     this.#deployment = deployment
     this.#registry = registry
   }
 
-  async export (path) {
+  async export(path) {
     const target = await workspace.create('deployment', path)
 
     await this.#deployment.export(target)
@@ -24,32 +24,32 @@ export class Operator {
     return target
   }
 
-  async prepare (path) {
+  async prepare(path) {
     return await this.#registry.prepare(path)
   }
 
-  async push () {
+  async push() {
     await this.#registry.push()
   }
 
-  async install (options = {}) {
+  async install(options = {}) {
     options = Object.assign({}, OPTIONS, options)
 
     await Promise.all([this.export(), this.push()])
     await this.#deployment.install(options)
   }
 
-  async template (options = {}) {
+  async template(options = {}) {
     await this.export()
 
     return await this.#deployment.template(options)
   }
 
-  variables () {
+  variables() {
     return this.#deployment.variables()
   }
 
-  tags () {
+  tags() {
     return this.#registry.tags()
   }
 }