@toa.io/origin 0.0.1

package/.husky/pre-commit

@@ -0,0 +1 @@
+npm test

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

package/README.md

@@ -0,0 +1,3 @@
+# Toa Origin
+
+[Exposition](https://github.com/toa-io/toa/tree/dev/extensions/exposition) Client

package/eslint.config.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const importPlugin = require('eslint-plugin-import')
+const neostandard = require('neostandard')
+
+module.exports = [
+  ...neostandard({
+    ts: true,
+    ignores: neostandard.resolveIgnoresFromGitignore(),
+  }),
+  {
+    plugins: {
+      import: importPlugin
+    }
+  },
+  {
+    rules: {
+      curly: ['error', 'multi'],
+      '@stylistic/space-before-function-paren': ['error', 'never'],
+      'padding-line-between-statements': [
+        'error',
+        {
+          blankLine: 'always',
+          prev: ['block-like', 'if'],
+          next: '*'
+        },
+        {
+          blankLine: 'always',
+          prev: '*',
+          next: ['block-like', 'if']
+        },
+        {
+          blankLine: 'always',
+          prev: ['const', 'let'],
+          next: ['expression', 'for']
+        },
+        {
+          blankLine: 'always',
+          prev: 'expression',
+          next: ['const', 'let']
+        },
+        {
+          blankLine: 'always',
+          prev: ['multiline-const', 'multiline-let'],
+          next: '*'
+        },
+        {
+          blankLine: 'always',
+          prev: '*',
+          next: ['multiline-const', 'multiline-let']
+        },
+        {
+          blankLine: 'always',
+          prev: '*',
+          next: 'return'
+        }
+      ],
+      'import/order': ['error', {
+        groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index', 'type'],
+        alphabetize: {
+          order: 'asc'
+        }
+      }],
+    },
+  },
+  {
+    files: ['**/*.ts'],
+    rules: {
+      'no-void': ['error', { allowAsStatement: true }],
+      '@typescript-eslint/consistent-type-imports': 'error'
+    }
+  },
+]

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@toa.io/origin",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Toa Origin",
+  "homepage": "git@github.com:toa-io/origin.git#readme",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:toa-io/origin.git"
+  },
+  "bugs": {
+    "url": "git@github.com:toa-io/origin.git/issues"
+  },
+  "main": "transpiled/index.js",
+  "types": "transpiled/index.d.ts",
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.17",
+    "eslint": "^9.26.0",
+    "eslint-plugin-import": "^2.31.0",
+    "husky": "^9.1.7",
+    "neostandard": "^0.12.1"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "prepublishOnly": "rm -rf transpiled && tsc",
+    "lint": "eslint .",
+    "format": "eslint . --fix",
+    "test": "node --test && npm run lint"
+  },
+  "dependencies": {
+    "error-value": "^0.4.4",
+    "meros": "^1.3.0",
+    "mitt": "^3.0.1"
+  }
+}

package/source/Failure.ts

@@ -0,0 +1,3 @@
+import { Err } from 'error-value'
+
+export class Failure extends Err<number> {}

package/source/Method.ts

@@ -0,0 +1,99 @@
+import { Err } from 'error-value'
+import mitt, { type Emitter } from 'mitt'
+import { request, type Options } from './request'
+import type { Failure } from './Failure'
+import type { OctetsEntry, WorkflowStep } from './Octets'
+
+export class Method<Entity = never> {
+  private readonly base: string
+  private readonly options?: Options
+
+  constructor(base: string, options?: Options) {
+    this.base = base
+    this.options = options
+  }
+
+  public async none(segments?: string[] | string, options?: Options): Promise<void | Failure> {
+    return await this.request(segments, options)
+  }
+
+  public async value<T = Entity>(segments?: string[] | string, options?: Options): Promise<T | Failure> {
+    return await this.request<T>(segments, options)
+  }
+
+  public async array<T = Entity[]>(segments?: string[] | string, options?: Options): Promise<T[] | Failure> {
+    return await this.request<T[]>(segments, options)
+  }
+
+  public async multipart<T = Entity>(
+    segments?: string[] | string,
+    options?: Options
+  ): Promise<AsyncGenerator<T, void, undefined> | Failure> {
+    const generator = await this.request<AsyncGenerator<{ body: string }>>(segments, options)
+
+    if (generator instanceof Error) return generator
+
+    const ack = await generator.next()
+
+    if (JSON.parse(ack.value.body) !== 'ACK') throw new Error('No ACK')
+
+    return (async function * () {
+      for await (const chunk of generator) {
+        const value = JSON.parse(chunk.body)
+
+        if (value === 'FIN') return
+
+        yield value
+      }
+    })()
+  }
+
+  public async octets<Events extends Record<string, unknown>>(
+    segments?: string[],
+    options?: Options
+  ): Promise<[OctetsEntry, Emitter<Events>] | Failure> {
+    const generator = await this.multipart(segments, options)
+
+    if (generator instanceof Error) return generator
+
+    const chunk = await generator.next()
+    const entry = chunk.value as OctetsEntry
+    const emitter = mitt<Events>()
+
+    void (async() => {
+      for await (const part of generator) {
+        const workflow = part as WorkflowStep
+
+        console.debug('octets chunk:', workflow)
+
+        const payload =
+          workflow.error === undefined
+            ? workflow.output
+            : new Err(workflow.error.code, workflow.error.message)
+
+        emitter.emit(workflow.step, payload as Events[typeof workflow.step])
+      }
+
+      emitter.off('*')
+    })()
+
+    return [entry, emitter]
+  }
+
+  private async request<T>(segments?: string | string[], options?: Options): Promise<T | Failure> {
+    const path = toPath(segments)
+
+    return await request<T>(`${this.base}${path}`, {
+      ...this.options,
+      ...options
+    })
+  }
+}
+
+function toPath(segments: string | string[] | undefined): string {
+  if (segments === undefined) return ''
+
+  if (typeof segments === 'string') return segments
+
+  return segments.filter((s) => s !== undefined).join('/') + '/'
+}

package/source/Octets.ts

@@ -0,0 +1,15 @@
+export interface OctetsEntry {
+  id: string
+}
+
+export interface WorkflowStep<K = string, T = unknown> {
+  step: K
+  status: 'completed' | 'exception'
+  output?: T
+  error: WorkflowError
+}
+
+interface WorkflowError {
+  code: string
+  message?: string
+}

package/source/Resource.ts

@@ -0,0 +1,18 @@
+import { Method } from './Method'
+import type { Options } from './request'
+
+export class Resource<T> {
+  public get: Method<T>
+  public post: Method<T>
+  public patch: Method<T>
+  public put: Method<T>
+  public delete: Method<never>
+
+  public constructor(base: string, options?: Omit<Options, 'method'>) {
+    this.get = new Method<T>(base, { method: 'GET', ...options })
+    this.post = new Method<T>(base, { method: 'POST', ...options })
+    this.patch = new Method<T>(base, { method: 'PATCH', ...options })
+    this.put = new Method<T>(base, { method: 'PUT', ...options })
+    this.delete = new Method(base, { method: 'DELETE', ...options })
+  }
+}

package/source/events.ts

@@ -0,0 +1,20 @@
+import mitt from 'mitt'
+import type { Options } from './request'
+
+export const events = mitt<Events>()
+
+export interface Events extends Record<string | symbol, unknown> {
+  challenge: string
+
+  request: {
+    id: string
+    path: string
+    options: Options
+  }
+
+  response: {
+    id: string
+    status: number
+    duration: number
+  }
+}

package/source/fail.ts

@@ -0,0 +1,13 @@
+import { Failure } from './Failure'
+import { events } from './events'
+
+export async function fail(response: Response): Promise<Failure> {
+  const payload =
+    response.headers.get('content-type') === 'application/json'
+      ? await response.json()
+      : await response.text()
+
+  events.emit(response.status, payload)
+
+  return new Failure(response.status)
+}

package/source/index.ts

@@ -0,0 +1,7 @@
+export { Resource } from './Resource'
+export { Method } from './Method'
+export { Failure } from './Failure'
+export { authenticate, request, use, type Options } from './request'
+export { events } from './events'
+export { connect } from './settings'
+export type * from './Octets'

package/source/ok.ts

@@ -0,0 +1,15 @@
+import { meros } from 'meros/browser'
+import { events } from './events'
+
+export async function ok<T>(response: Response): Promise<T> {
+  const challenge = response.headers.get('authorization')
+
+  if (challenge !== null) events.emit('challenge', challenge)
+
+  const type = response.headers.get('content-type')
+
+  if (type?.startsWith('multipart/')) return (await meros(response)) as T
+  else if (type === 'application/json') return (await response.json()) as T
+  else if (type?.startsWith('text/')) return (await response.text()) as T
+  else return (await response.blob()) as T
+}

package/source/request.ts

@@ -0,0 +1,74 @@
+import { events } from './events'
+import { fail } from './fail'
+import { ok } from './ok'
+import { settings } from './settings'
+import type { Failure } from './Failure'
+
+const delay = settings.delay
+
+if (delay) console.warn(`API delay is enabled (${delay}ms)`)
+
+let challenge: string | null = null
+
+export function authenticate(value: string | null) {
+  challenge = value
+}
+
+let _fetch = fetch
+
+export function use(fetcher: typeof fetch) {
+  _fetch = fetcher
+}
+
+export async function request<T = unknown>(
+  path: string,
+  options: Options = {}
+): Promise<T | Failure> {
+  options.headers ??= {}
+  options.headers['accept'] ??= 'application/json'
+
+  if (delay)
+    options.headers['sleep'] = Math.round((Math.random() * delay) / 2 + delay / 2).toString()
+
+  const authentication = options.credentials === 'include'
+
+  if (options.body !== undefined)
+    if (options.body instanceof File || options.body instanceof ReadableStream) {
+      options.method ??= 'POST'
+      options.duplex = 'half'
+      options.headers['content-type'] ??= 'application/octet-stream'
+    } else {
+      options.body = JSON.stringify(options.body)
+      options.headers['content-type'] ??= 'application/json'
+    }
+
+  if (authentication && options.headers['authorization'] === undefined) {
+    if (challenge === null)
+      throw new Error(`Credentials must be set before sending authenticated request ${options.method ?? 'GET'} ${path}`)
+
+    options.headers['authorization'] = challenge
+    delete options.credentials // no cookies
+  }
+
+  const start = performance.now()
+
+  const id =
+    typeof window !== 'undefined' && (window.crypto.randomUUID?.() ?? Math.random().toString())
+
+  if (id) events.emit('request', { id, path, options })
+
+  const response = await _fetch(settings.origin + path, options)
+
+  if (id)
+    events.emit('response', { id, status: response.status, duration: performance.now() - start })
+
+  if (!response.ok) return await fail(response)
+  else return await ok<T>(response)
+}
+
+export interface Options extends Omit<RequestInit, 'headers'> {
+  duplex?: 'half'
+
+  body?: any
+  headers?: Record<string, string>
+}

package/source/settings.ts

@@ -0,0 +1,12 @@
+const settings: Partial<Settings> = {} as const
+
+export function connect(set: Settings) {
+  Object.assign(settings, set)
+}
+
+interface Settings {
+  origin: string
+  delay: number
+}
+
+export { settings }

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "outDir": "./transpiled",
+    "rootDir": "./source",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "ESNext",
+    "sourceMap": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "incremental": true,
+    "strict": true,
+    "experimentalDecorators": true,
+    "noImplicitOverride": true,
+    "allowJs": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "source/**/*"
+  ]
+}