@toa.io/extensions.origins 0.20.0-dev.31 → 0.20.0-dev.34

package/source/extension.test.ts

@@ -0,0 +1,161 @@
+import { generate } from 'randomstring'
+import { encode } from 'msgpackr'
+import { Locator } from '@toa.io/core'
+import { deployment, type Instance } from './extension'
+import type { Annotation, Properties } from './annotation'
+import type { Manifest } from './manifest'
+import type { Dependency } from '@toa.io/operations'
+
+const locator = new Locator(generate(), generate())
+const NAMESPACE = locator.namespace.toUpperCase()
+const NAME = locator.name.toUpperCase()
+
+it('should deploy pointer variables', async () => {
+  const manifest: Manifest = { queue: null }
+  const instance = { locator, manifest } as unknown as Instance
+  const url = 'amqp://host-' + generate()
+
+  const annotation: Annotation = {
+    [locator.id]: {
+      queue: url
+    }
+  }
+
+  const deploy = deployment([instance], annotation)
+
+  const expected: Dependency = {
+    variables: {
+      [locator.label]: expect.arrayContaining([
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}_QUEUE`,
+          value: url
+        }
+      ])
+    }
+  }
+
+  expect(deploy)
+    .toMatchObject(expected)
+})
+
+it('should deploy default origin', async () => {
+  const example = 'http://api.example.com'
+  const manifest: Manifest = { example }
+  const instance = { locator, manifest } as unknown as Instance
+  const annotation: Annotation = {}
+  const deploy = deployment([instance], annotation)
+
+  const expected: Dependency = {
+    variables: {
+      [locator.label]: expect.arrayContaining([
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}_EXAMPLE`,
+          value: example
+        }
+      ])
+    }
+  }
+
+  expect(deploy)
+    .toMatchObject(expected)
+})
+
+it('should deploy properties', async () => {
+  const manifest: Manifest = {}
+  const instance = { locator, manifest } as unknown as Instance
+  const properties: Properties = {
+    '.http': {
+      '/^http:\\/\\/\\w+api.example.com/': true
+    }
+  }
+
+  const annotation: Annotation = {
+    [locator.id]: properties
+  }
+
+  const deploy = deployment([instance], annotation)
+  const value = encode(properties).toString('base64')
+
+  const expected: Dependency = {
+    variables: {
+      [locator.label]: expect.arrayContaining([
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}__PROPERTIES`,
+          value
+        }
+      ])
+    }
+  }
+
+  expect(deploy)
+    .toMatchObject(expected)
+})
+
+it('should deploy properties with null manifest', async () => {
+  const manifest: Manifest = null
+  const instance = { locator, manifest } as unknown as Instance
+  const properties: Properties = {
+    '.http': {
+      '/^http:\\/\\/\\w+api.example.com/': true
+    }
+  }
+
+  const annotation: Annotation = {
+    [locator.id]: properties
+  }
+
+  const deploy = deployment([instance], annotation)
+  const value = encode(properties).toString('base64')
+
+  const expected: Dependency = {
+    variables: {
+      [locator.label]: expect.arrayContaining([
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}__PROPERTIES`,
+          value
+        }
+      ])
+    }
+  }
+
+  expect(deploy)
+    .toMatchObject(expected)
+})
+
+it('should deploy credentials for amqp', async () => {
+  const manifest: Manifest = { queue: null }
+  const instance = { locator, manifest } as unknown as Instance
+  const url = 'amqp://host-' + generate()
+
+  const annotation: Annotation = {
+    [locator.id]: {
+      queue: url
+    }
+  }
+
+  const deploy = deployment([instance], annotation)
+
+  const expected: Dependency = {
+    variables: {
+      [locator.label]: expect.arrayContaining([
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}_QUEUE_USERNAME`,
+          secret: {
+            name: `toa-origins-${locator.label}-queue`,
+            key: 'username'
+          }
+        },
+        {
+          name: `TOA_ORIGINS_${NAMESPACE}_${NAME}_QUEUE_PASSWORD`,
+          secret: {
+            name: `toa-origins-${locator.label}-queue`,
+            key: 'password'
+          }
+        }
+      ])
+    }
+  }
+
+  expect(deploy)
+    .toMatchObject(expected)
+})

package/source/extension.ts

@@ -0,0 +1,60 @@
+import { encode } from 'msgpackr'
+import { createVariables, type Request } from '@toa.io/pointer'
+import { merge } from '@toa.io/generic'
+import { normalize, split, type Annotation, type Properties, type Origins } from './annotation'
+import { type Manifest, validate } from './manifest'
+import type { Locator } from '@toa.io/core'
+import type { Dependency, Variables } from '@toa.io/operations'
+import type { context } from '@toa.io/norm'
+
+export function deployment (instances: Instance[], annotation: Annotation = {}): Dependency {
+  normalize(instances, annotation)
+
+  const variables: Variables = {}
+
+  for (const instance of instances) {
+    const component = annotation[instance.locator.id]
+    const { origins, properties } = split(component)
+    const instanceVariables = createInstanceVariables(instance, origins)
+    const propertiesVariable = createPropertiesVariable(instance.locator, properties)
+
+    merge(variables, instanceVariables)
+    merge(variables, propertiesVariable)
+  }
+
+  return { variables }
+}
+
+export function manifest (manifest: Manifest): Manifest {
+  validate(manifest)
+
+  return manifest
+}
+
+function createInstanceVariables (instance: Instance, origins: Origins): Variables {
+  if (instance.manifest === null) return {}
+
+  const label: string = instance.locator.label
+  const id = ID_PREFIX + label
+  const selectors = Object.keys(instance.manifest)
+  const request: Request = { group: label, selectors }
+
+  return createVariables(id, origins, [request])
+}
+
+function createPropertiesVariable (locator: Locator, properties: Properties): Variables {
+  const name = ENV_PREFIX + locator.uppercase + PROPERTIES_SUFFIX
+  const value = encode(properties).toString('base64')
+
+  return {
+    [locator.label]: [
+      { name, value }
+    ]
+  }
+}
+
+export const ID_PREFIX = 'origins-'
+export const ENV_PREFIX = 'TOA_ORIGINS_'
+export const PROPERTIES_SUFFIX = '__PROPERTIES'
+
+export type Instance = context.Dependency<Manifest>

package/source/index.ts

@@ -0,0 +1,2 @@
+export { deployment, manifest } from './extension'
+export { Factory } from './Factory'

package/source/manifest.test.ts

@@ -0,0 +1,30 @@
+import { type Manifest, validate } from './manifest'
+
+let manifest: Manifest
+
+it('should not throw if valid', async () => {
+  manifest = {
+    one: 'http://localhost',
+    two: null
+  }
+
+  expect(run).not.toThrow()
+})
+
+it('should throw if not a uri', async () => {
+  manifest = {
+    one: 'not a URI'
+  }
+
+  expect(run).toThrow('must match format')
+})
+
+it('should not throw on null manifest', async () => {
+  manifest = null
+
+  expect(run).not.toThrow()
+})
+
+function run (): void {
+  validate(manifest)
+}

package/source/manifest.ts

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path'
+import * as schemas from '@toa.io/schemas'
+
+export function validate (manifest: Manifest): void {
+  if (manifest !== null) schema.validate(manifest)
+}
+
+const path = resolve(__dirname, '../schemas/manifest.cos.yaml')
+const schema = schemas.schema(path)
+
+export type Manifest = Record<string, string | null> | null

package/source/protocols/amqp/.test/aspect.fixtures.js

@@ -9,7 +9,7 @@ const originCount = random(5) + 2
 for (let j = 0; j < originCount; j++) {
   const origin = generate()
 
-  manifest[origin] = 'amqp://' + generate()
+  manifest[origin] = ['amqp://' + generate()]
 }
 
 exports.manifest = manifest

package/source/protocols/amqp/aspect.js

@@ -2,32 +2,25 @@
 
 const { assert } = require('comq')
 const { Connector } = require('@toa.io/core')
-const { shards } = require('@toa.io/generic')
+const protocol = require('./index')
 
-const { id } = require('./id')
-
-/**
- * @implements {toa.origins.amqp.Aspect}
- */
 class Aspect extends Connector {
-  name = id
-  /** @type {toa.origins.Manifest} */
-  #manifest
+  name = protocol.id
+
+  #resolve
 
   /** @type {Record<string, Partial<comq.IO>>} */
   #origins = {}
 
-  /**
-   * @param {toa.origins.Manifest} manifest
-   */
-  constructor (manifest) {
+  constructor (resolve) {
     super()
 
-    this.#manifest = manifest
+    this.#resolve = resolve
   }
 
   async open () {
-    const promises = Object.entries(this.#manifest).map(this.#open)
+    const cfg = await this.#resolve()
+    const promises = Object.entries(cfg.origins).map(this.#open)
 
     await Promise.all(promises)
   }
@@ -39,11 +32,14 @@ class Aspect extends Connector {
   }
 
   async invoke (origin, method, ...args) {
+    if (this.#origins[origin]?.[method] === undefined) {
+      throw new Error(`Origin "${origin}" or method "${method}" is undefined`)
+    }
+
     return this.#origins[origin][method](...args)
   }
 
-  #open = async ([origin, reference]) => {
-    const references = shards(reference)
+  #open = async ([origin, references]) => {
     const io = await assert(...references)
 
     this.#origins[origin] = restrict(io)
@@ -67,11 +63,8 @@ function restrict (io) {
   }
 }
 
-/**
- * @param {toa.origins.Manifest} manifest
- */
-function create (manifest) {
-  return new Aspect(manifest)
+function create (resolve) {
+  return new Aspect(resolve)
 }
 
 exports.create = create

package/source/protocols/http/.aspect/permissions.js

@@ -1,23 +1,26 @@
 'use strict'
 
 const { echo } = require('@toa.io/generic')
+const { Connector } = require('@toa.io/core')
 
-/**
- * @implements {toa.origins.http.Permissions}
- */
-class Permissions {
-  #default = process.env.TOA_DEV === '1'
-
+class Permissions extends Connector {
   /** @type {RegExp[]} */
   #allowances = []
 
   /** @type {RegExp[]} */
   #denials = []
 
-  /**
-   * @param {toa.origins.http.Properties} properties
-   */
-  constructor (properties) {
+  #resolve
+
+  constructor (resolve) {
+    super()
+
+    this.#resolve = resolve
+  }
+
+  async open () {
+    const { properties } = await this.#resolve()
+
     if (properties !== undefined) this.#parse(properties)
   }
 

package/source/protocols/http/aspect.js

@@ -1,41 +1,35 @@
 'use strict'
 
-/**
- * @typedef {import('node-fetch').RequestInit} Request
- * @typedef {import('node-fetch').Response} Response
- */
-
 const fetch = require('node-fetch')
 
 const { Connector } = require('@toa.io/core')
 const { retry } = require('@toa.io/generic')
 
 const { Permissions } = require('./.aspect/permissions')
-const { id } = require('./id')
 const protocols = require('./protocols')
+const protocol = require('./index')
 
-/**
- * @implements {toa.origins.http.Aspect}
- */
 class Aspect extends Connector {
   /** @readonly */
-  name = id
+  name = protocol.id
 
-  /** @type {toa.origins.Manifest} */
+  #resolve
   #origins
-
-  /** @type {toa.origins.http.Permissions} */
   #permissions
 
-  /**
-   * @param {toa.origins.Manifest} manifest
-   * @param {toa.origins.http.Permissions} permissions
-   */
-  constructor (manifest, permissions) {
+  constructor (resolve, permissions) {
     super()
 
-    this.#origins = manifest
+    this.#resolve = resolve
     this.#permissions = permissions
+
+    this.depends(permissions)
+  }
+
+  async open () {
+    const { origins } = await this.#resolve()
+
+    this.#origins = origins
   }
 
   async invoke (name, path, request, options) {
@@ -56,23 +50,12 @@ class Aspect extends Connector {
     return this.#request(url.href, request, options?.retry)
   }
 
-  /**
-   * @param {string} url
-   * @param {Request} request
-   * @return {Promise<Response>}
-   */
   async #invokeURL (url, request) {
     if (this.#permissions.test(url) === false) throw new Error(`URL '${url}' is not allowed`)
 
     return this.#request(url, request)
   }
 
-  /**
-   * @param {string} url
-   * @param {Request} request
-   * @param {toa.generic.retry.Options} [options]
-   * @return {Promise<Response>}
-   */
   async #request (url, request, options) {
     const call = () => fetch(url, request)
 
@@ -117,14 +100,10 @@ function isAbsoluteURL (path) {
 
 const PLACEHOLDER = /\*/g
 
-/**
- * @param {toa.origins.Manifest} manifest
- * @param {toa.origins.http.Properties} [properties]
- */
-function create (manifest, properties) {
-  const permissions = new Permissions(properties)
+function create (resolve) {
+  const permissions = new Permissions(resolve)
 
-  return new Aspect(manifest, permissions)
+  return new Aspect(resolve, permissions)
 }
 
 exports.create = create

package/source/protocols/index.ts

@@ -0,0 +1,16 @@
+'use strict'
+
+import { type Resolver } from '../Factory'
+import amqp from './amqp'
+import http from './http'
+import type { extensions } from '@toa.io/core'
+
+export const protocols: Protocol[] = [http, amqp]
+
+export interface Protocol {
+  id: ProtocolID
+  protocols: string[]
+  create: (resolver: Resolver) => extensions.Aspect
+}
+
+export type ProtocolID = 'http' | 'amqp'

package/transpiled/Factory.d.ts

@@ -0,0 +1,17 @@
+import { type URIMap } from '@toa.io/pointer';
+import type { Locator, extensions } from '@toa.io/core';
+import type { Manifest } from './manifest';
+export declare class Factory implements extensions.Factory {
+    aspect(locator: Locator, manifest: Manifest): extensions.Aspect[];
+    private createAspect;
+    private resolver;
+    private getURIs;
+    private filterOrigins;
+    private readOrigin;
+    private getProperties;
+}
+export interface Configuration {
+    origins: URIMap;
+    properties: Record<string, boolean>;
+}
+export type Resolver = () => Promise<Configuration>;

package/transpiled/Factory.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+const msgpackr_1 = require("msgpackr");
+const pointer_1 = require("@toa.io/pointer");
+const generic_1 = require("@toa.io/generic");
+const protocols_1 = require("./protocols");
+const extension_1 = require("./extension");
+class Factory {
+    aspect(locator, manifest) {
+        return protocols_1.protocols.map((protocol) => this.createAspect(locator, manifest, protocol));
+    }
+    createAspect(locator, manifest, protocol) {
+        const resolver = this.resolver(locator, manifest, protocol);
+        return protocol.create(resolver);
+    }
+    resolver(locator, manifest, protocol) {
+        return (0, generic_1.memo)(async () => {
+            const uris = await this.getURIs(locator, manifest);
+            const allProperties = this.getProperties(locator);
+            const origins = this.filterOrigins(uris, protocol.protocols);
+            const properties = allProperties['.' + protocol.id] ?? {};
+            return { origins, properties };
+        });
+    }
+    async getURIs(locator, manifest) {
+        const map = {};
+        if (manifest === null)
+            return map;
+        for (const [name, value] of Object.entries(manifest))
+            map[name] = value !== null ? [value] : await this.readOrigin(locator, name);
+        return map;
+    }
+    filterOrigins(uris, protocols) {
+        const filtered = {};
+        for (const [name, references] of Object.entries(uris)) {
+            const url = new URL(references[0]);
+            if (protocols.includes(url.protocol))
+                filtered[name] = references;
+        }
+        return filtered;
+    }
+    async readOrigin(locator, name) {
+        const id = extension_1.ID_PREFIX + locator.label;
+        return await (0, pointer_1.resolve)(id, name);
+    }
+    getProperties(locator) {
+        const variable = extension_1.ENV_PREFIX + locator.uppercase + extension_1.PROPERTIES_SUFFIX;
+        const value = process.env[variable];
+        if (value === undefined)
+            return {};
+        const buffer = Buffer.from(value, 'base64');
+        return (0, msgpackr_1.decode)(buffer);
+    }
+}
+exports.Factory = Factory;
+//# sourceMappingURL=Factory.js.map

package/transpiled/Factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory.js","sourceRoot":"","sources":["../source/Factory.ts"],"names":[],"mappings":"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"}

package/transpiled/annotation.d.ts

@@ -0,0 +1,10 @@
+import type { Instance } from './extension';
+export declare function normalize(instances: Instance[], annotation: Annotation): void;
+export declare function split(component: Component): {
+    origins: Origins;
+    properties: Properties;
+};
+export type Component = Origins | Properties;
+export type Annotation = Record<string, Component>;
+export type Properties = Partial<Record<'.http', Record<string, boolean>>>;
+export type Origins = Record<string, string | string[]>;

package/transpiled/annotation.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = exports.normalize = void 0;
+const node_path_1 = require("node:path");
+const schemas = __importStar(require("@toa.io/schemas"));
+const protocols_1 = require("./protocols");
+function normalize(instances, annotation) {
+    schema.validate(annotation);
+    mergeDefaults(annotation, instances);
+    checkProtocols(annotation);
+}
+exports.normalize = normalize;
+function split(component) {
+    const origins = {};
+    const properties = {};
+    for (const [key, value] of Object.entries(component))
+        if (key[0] === '.')
+            properties[key] = value;
+        else
+            origins[key] = value;
+    return { origins, properties };
+}
+exports.split = split;
+function mergeDefaults(annotation, instances) {
+    for (const instance of instances) {
+        const component = annotation[instance.locator.id] ?? {};
+        annotation[instance.locator.id] = mergeInstance(component, instance);
+    }
+}
+function mergeInstance(origins, instance) {
+    const id = instance.locator.id;
+    if (instance.manifest === null)
+        return origins;
+    for (const [origin, value] of Object.entries(instance.manifest))
+        if (origins[origin] === undefined)
+            if (value === null)
+                throw new Error(`Origin '${origin}' is not defined for '${id}'`);
+            else
+                origins[origin] = value;
+    return origins;
+}
+function checkProtocols(annotation) {
+    for (const component of Object.values(annotation)) {
+        const { origins } = split(component);
+        const urlSets = Object.values(origins);
+        for (const urls of urlSets)
+            checkURLs(Array.isArray(urls) ? urls : [urls]);
+    }
+}
+function checkURLs(urls) {
+    let id = null;
+    for (const url of urls) {
+        const protocol = resolveProtocol(url);
+        if (id === null)
+            id = protocol.id;
+        else if (id !== protocol.id)
+            throw new Error(`Origin has inconsistent protocols: ${id}, ${protocol.id}`);
+    }
+}
+function resolveProtocol(reference) {
+    const url = new URL(reference);
+    for (const protocol of protocols_1.protocols)
+        if (protocol.protocols.includes(url.protocol))
+            return protocol;
+    throw new Error(`Protocol '${url.protocol}' is not supported.`);
+}
+const path = (0, node_path_1.resolve)(__dirname, '../schemas/annotation.cos.yaml');
+const schema = schemas.schema(path);
+//# sourceMappingURL=annotation.js.map