@interopio/bridge 0.0.1-alpha

package/bin/bridge.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+"use strict";
+
+import module from 'node:module';
+
+module.enableCompileCache?.()
+
+await import('../src/main.mts');

package/gen/instance/GeneratedBuildInfo.ts

@@ -0,0 +1,4 @@
+// eslint-disable
+//generated
+
+export const VERSION = '0.0.1-alpha';

package/license.md

@@ -0,0 +1,5 @@
+# License Information
+
+This package is subject to the interop.io Developer License Agreement. For full details, please visit the link below. If you have questions regarding licensing or usage, reach out to our support team at [support@interop.io](mailto:support@interop.io).
+
+- [Interop.io Developer License Agreement](https://interop.io/developer-license-agreement/)

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@interopio/bridge",
+    "version": "0.0.1-alpha",
+    "license": "see license in license.md",
+    "author": "interop.io",
+    "homepage": "https://docs.interop.io/bridge",
+    "keywords": [
+        "io.bridge",
+        "bridge",
+        "io.connect",
+        "glue42",
+        "interop.io"
+    ],
+    "type": "module",
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "import": "./src/index.ts"
+        }
+    },
+    "bin": {
+        "bridge": "./bin/bridge.js"
+    },
+    "scripts": {
+        "test": "mocha test --recursive"
+    },
+    "dependencies": {
+        "@interopio/gateway-server": "^0.5.0-beta",
+        "dotenv": "^17.2.0",
+        "jsrsasign": "^11.1.0",
+        "nanoid": "^5.0.9"
+    },
+    "devDependencies": {
+        "@types/jsrsasign": "^10.5.15",
+        "rand-seed": "^3.0.0"
+    },
+    "engines": {
+        "node": ">=22.2.0"
+    }
+}

package/readme.md

@@ -0,0 +1,10 @@
+# @interopio/bridge
+
+## Getting Started
+
+- Install Node.js 24.3+
+- Set IO_BRIDGE_LICENSE_KEY environment variable
+- From command line, run:
+```shell
+npx @interopio/bridge
+```

package/src/cluster/Address.ts

@@ -0,0 +1,57 @@
+import {getByName, type IpAddress} from '../utils/network.ts';
+import {type Comparator, compareArrays} from '../utils/collections.ts';
+
+export type Address = Readonly<{type: 4 | 6, host: string, port: number, address: IpAddress}>;
+export function addressAsString(address: Pick<Address, 'host' | 'port' | 'type'>): string {
+    // todo: do better for ipv6
+    return `${address.host}:${address.port}`;
+}
+export async function toIpAddress(address: Address): Promise<IpAddress> {
+    return await getByName(scopedHost(address));
+}
+
+export async function fromHostname(hostname: string, port: number): Promise<Address> {
+    return new AddressImpl(hostname, await getByName(hostname), port);
+}
+export function fromIpAddress(address: IpAddress, port: number): Address {
+
+    return new AddressImpl(undefined, address, port);
+}
+
+class AddressImpl {
+    readonly type: 4 | 6;
+    readonly host: string;
+    readonly port: number;
+    readonly address: IpAddress;
+
+    constructor(hostname: string | undefined, ipAddress: IpAddress, port : number) {
+        const type = ipAddress.family;
+        if (type !== 4 && type !== 6) {
+            throw new Error('unexpected address type');
+        }
+        this.type= type;
+        this.host = hostname ?? ipAddress.address;
+        this.port = port;
+        this.address = ipAddress;
+    }
+}
+
+function scopedHost(address: Address): string {
+    if (address.type === 6) {
+        return `[${address.host}]`;
+    }
+    return address.host;
+}
+
+export const compareAddress: Comparator<Address> = (a1: Address, a2: Address) => {
+    const addressBytes1 = a1.address.addressBytes;
+    const addressBytes2 = a2.address.addressBytes;
+    const result = compareArrays(addressBytes1, 0, addressBytes1.length, addressBytes2, 0, addressBytes2.length, (b1, b2) => {
+        return b1 === b2 ? 0 : (b1 > b2 ? 1 : -1);
+    });
+    if (result !== 0) {
+        return result;
+    }
+
+    return a1.port === a2.port ? 0 : (a1.port > a2.port ? 1 : -1);
+}

package/src/cluster/Cluster.ts

@@ -0,0 +1,13 @@
+import { Version } from '../version/Version.ts';
+import { type Member } from './Member.ts';
+import { type MembershipListener } from './MembershipListener.ts';
+
+type RegistrationId = number
+
+interface Cluster {
+    addMembershipListener(listener: MembershipListener) : RegistrationId
+    readonly version: Version
+    readonly members: ReadonlySet<Member>
+    readonly localMember: Member
+    readonly clusterTime: number  
+}

package/src/cluster/Endpoint.ts

@@ -0,0 +1,5 @@
+import {SocketAddress} from 'node:net';
+
+interface Endpoint {
+    readonly socketAddress: SocketAddress;
+}

package/src/cluster/Member.ts

@@ -0,0 +1,9 @@
+import { type MemberVersion } from '../version/MemberVersion.ts';
+import { type Address } from './Address.ts';
+
+export interface Member {
+    readonly local: boolean
+    readonly address: Address
+    readonly uuid: string
+    readonly version: MemberVersion
+}

package/src/cluster/MembershipListener.ts

@@ -0,0 +1,6 @@
+import {type Member} from './Member.ts';
+
+export interface MembershipListener {
+    onMemberAdded(member: Member): void
+    onMemberRemoved(member: Member): void
+}

package/src/config/Config.ts

@@ -0,0 +1,100 @@
+import {type Properties, type PropertyType} from './Properties.ts';
+import {KubernetesConfig} from './KubernetesConfig.ts';
+import {
+    DefaultDiscoveryConfig,
+    type DiscoveryConfig
+} from './DiscoveryConfig.ts';
+
+export class AutoDetectionConfig {
+    enabled: boolean = true;
+}
+
+export interface MulticastConfig {
+    readonly group: string
+    readonly port: number
+}
+class DefaultMulticastConfig implements MulticastConfig {
+    enabled: boolean = false;
+    group: string = '239.1.2.3';
+    port: number = 34567;
+}
+export interface TcpIpConfig {
+    members: string[]
+}
+class DefaultTcpIpConfig implements TcpIpConfig {
+    enabled: boolean = false;
+    members: string[] = [];
+}
+export class JoinConfig {
+    private _multicast= new DefaultMulticastConfig();
+    private _tcpIp = new DefaultTcpIpConfig();
+    private _kubernetes = new KubernetesConfig();
+    private _discovery = new DefaultDiscoveryConfig();
+    private _autoDetection = new AutoDetectionConfig();
+
+    get discovery(): DiscoveryConfig {
+        return this._discovery;
+    }
+
+    get multicast(): MulticastConfig {
+        return this._multicast;
+    }
+
+    get autoDetectionEnabled(): boolean {
+        return this._autoDetection.enabled
+            && !this._multicast.enabled
+            && !this._tcpIp.enabled
+            && !this._kubernetes.enabled
+            && !this._discovery.enabled;
+    }
+}
+
+export class NetworkConfig {
+    public static readonly DEFAULT_PORT: number = 8383;
+    port: number = NetworkConfig.DEFAULT_PORT;
+    reuseAddress: boolean;
+    publicAddress?: string;
+    join = new JoinConfig();
+
+    constructor() {
+        this.reuseAddress = process.platform !== "win32";
+    }
+}
+
+export class ServerConfig {
+    port?: number = undefined;
+    host?: string = undefined;
+    mesh: {
+        ping?: number
+    } = {};
+    gateway: {
+        enabled?: boolean,
+        contexts: {
+            lifetime: 'retained' | 'ref-counted' | 'ownership'
+        }
+    } = {
+        contexts: {
+            lifetime: 'retained'
+        }
+    }
+}
+
+export class Config {
+    properties: Properties = {};
+    network = new NetworkConfig();
+    license: string
+    readonly server: ServerConfig;
+    constructor() {
+        this.server = new ServerConfig();
+    }
+
+    get<T extends PropertyType>(name: string): T {
+        const value = this.properties[name] as T;
+        return value;
+    }
+
+    set<T extends PropertyType>(name: string, value: T): Config {
+        this.properties[name] = value;
+        return this;
+    }
+}

package/src/config/DiscoveryConfig.ts

@@ -0,0 +1,21 @@
+import type {DiscoveryServiceFactory, DiscoveryStrategyFactory} from '../discovery/index.ts';
+import type {Properties} from './Properties.ts';
+
+export interface DiscoveryStrategyConfig {
+    readonly discoveryStrategyFactory?: DiscoveryStrategyFactory
+    readonly properties: Properties
+}
+export interface DiscoveryConfig {
+    readonly discoveryStrategyConfigs: ReadonlyArray<DiscoveryStrategyConfig>
+    readonly discoveryServiceFactory?: DiscoveryServiceFactory
+}
+
+export class DefaultDiscoveryConfig implements DiscoveryConfig
+{
+    discoveryStrategyConfigs: DiscoveryStrategyConfig[] = [];
+    discoveryServiceFactory?: DiscoveryServiceFactory;
+
+    get enabled() {
+        return this.discoveryStrategyConfigs.length > 0;
+    }
+}

package/src/config/Duration.ts

@@ -0,0 +1,168 @@
+const UNITS_PATTERN = /^(\d+)(d|h|m|s|ms|us|µs|ns)$/;
+
+export type Unit = keyof typeof SCALES;
+
+export function unitForSymbol(symbol: string): Unit {
+    switch (symbol.toLowerCase()) {
+        case 'ns':
+            return 'nanoseconds';
+        case 'us':
+        case 'µs':
+            return 'microseconds';
+        case 'ms':
+            return 'milliseconds';
+        case 's':
+            return 'seconds';
+        case 'm':
+            return 'minutes';
+        case 'h':
+            return 'hours';
+        case 'd':
+            return 'days';
+    }
+    throw new Error(`Unsupported unit symbol: ${symbol}`);
+}
+
+export function symbolForUnit(unit: Unit): string {
+    switch (unit) {
+        case 'days': return 'd';
+        case 'hours': return 'h';
+        case 'minutes': return 'm';
+        case 'seconds': return 's';
+        case 'milliseconds': return 'ms';
+        case 'microseconds': return 'us';
+        case 'nanoseconds': return 'ns';
+    }
+}
+
+const SCALES: { [key :string ]: bigint } = {
+    nanoseconds: 1n,
+    microseconds: 1000n,
+    milliseconds: 1000000n,
+    seconds: 1000000000n,
+    minutes: 60n * 1000000000n,
+    hours: 60n * 60n * 1000000000n,
+    days: 24n * 60n * 60n * 1000000000n,
+}
+
+function toNanos(unit: Unit, duration: number | bigint) {
+    const scale = SCALES[unit];
+    const ns = BigInt(duration) * scale;
+    return ns;
+}
+
+function toMicros(unit: Unit, duration: number | bigint): bigint {
+    const scale = SCALES[unit];
+    let microScale = SCALES.microseconds;
+    if (scale <= microScale) {
+        return scale === microScale ? BigInt(duration) : BigInt(duration) / (microScale / scale);
+    }
+    else {
+        return BigInt(duration) * (scale / microScale);
+    }
+}
+
+function toMillis(unit: Unit, duration: number | bigint) : bigint {
+    const scale = SCALES[unit];
+    let milliScale = SCALES.milliseconds;
+    if (scale <= milliScale) {
+        return scale === milliScale ? BigInt(duration) : BigInt(duration) / (milliScale / scale);
+    }
+    else {
+        return BigInt(duration) * (scale / milliScale);
+    }
+}
+
+function toSeconds(unit: Unit, duration: number | bigint): bigint {
+    const scale = SCALES[unit];
+    const secondScale = SCALES.seconds;
+    if (scale <= secondScale) {
+        return scale === secondScale ? BigInt(duration) : BigInt(duration) / (secondScale / scale);
+    }
+    else {
+        return BigInt(duration) * (scale / secondScale);
+    }
+}
+
+export function convert(targetUnit: Unit, quantity: number | bigint, sourceUnit: Unit): bigint {
+    switch (targetUnit) {
+        case 'nanoseconds': return toNanos(sourceUnit, quantity);
+        case 'microseconds': return toMicros(sourceUnit, quantity);
+        case 'milliseconds': return toMillis(sourceUnit, quantity);
+        case 'seconds': return toSeconds(sourceUnit, quantity);
+        default: throw new Error('not implemented');
+    }
+}
+
+abstract class Duration {
+    readonly unit: Unit;
+    readonly quantity: number;
+
+    /*protected*/ constructor(value: string, minUnit: Unit, max?: number) {
+        const match = UNITS_PATTERN.exec(value);
+        if (!match) {
+            throw new Error(`Invalid duration: ${value}`);
+        }
+        this.quantity = parseInt(match[1]);
+        this.unit = unitForSymbol(match[2]);
+        if (max) {
+            if (SCALES[this.unit] < SCALES[minUnit]) {
+                throw new Error(`Duration must be at least ${minUnit}`);
+            }
+            if (convert(minUnit, this.quantity, this.unit) > max) {
+                throw new Error(`Invalid Duration: ${value}. Must be at most ${max - 1} in ${minUnit}`);
+            }
+        }
+    }
+}
+
+export class NanosecondsDuration extends Duration {
+    constructor(value: string) {
+        super(value, 'nanoseconds', Number.MAX_SAFE_INTEGER);
+    }
+
+    toNanoseconds() {
+        return toNanos(this.unit, this.quantity);
+    }
+}
+export class MicrosecondsDuration extends Duration {
+    constructor(value: string) {
+        super(value, 'microseconds', Number.MAX_SAFE_INTEGER);
+    }
+
+    toMicroseconds() {
+        return convert('microseconds', this.quantity, this.unit);
+    }
+
+    toSeconds() {
+        return convert('seconds', this.quantity, this.unit);
+    }
+}
+
+export class MillisecondsDuration extends Duration {
+    constructor(value: string) {
+        super(value, 'milliseconds', Number.MAX_SAFE_INTEGER);
+    }
+
+    toMilliseconds() {
+        return convert('milliseconds', this.quantity, this.unit);
+    }
+}
+
+export class SecondsDuration extends Duration {
+    constructor(value: string) {
+        super(value, 'seconds', Number.MAX_SAFE_INTEGER);
+    }
+
+    toMilliseconds() {
+        return toMillis(this.unit, this.quantity);
+    }
+
+    toNanoSeconds() {
+        return toNanos(this.unit, this.quantity);
+    }
+
+    toSeconds() {
+        return toSeconds(this.unit, this.quantity);
+    }
+}

package/src/config/KubernetesConfig.ts

@@ -0,0 +1,7 @@
+import { NamedDiscoveryConfig } from './NamedDiscoveryConfig.ts';
+
+export class KubernetesConfig extends NamedDiscoveryConfig<KubernetesConfig> {
+    constructor() {
+        super("kubernetes");
+    }
+}

package/src/config/NamedDiscoveryConfig.ts

@@ -0,0 +1,17 @@
+export abstract class NamedDiscoveryConfig<T extends NamedDiscoveryConfig<T>>  {
+    readonly tag;
+    private _enabled: boolean = false;
+
+    constructor(tag: string) {
+        this.tag = tag;
+    }
+
+    setEnabled(enabled: boolean): T {
+        this._enabled = enabled;
+        return this as unknown as T;
+    }
+
+    get enabled(): boolean {
+        return this._enabled;
+    }
+}

package/src/config/Properties.ts

@@ -0,0 +1,49 @@
+export interface PropertyDefinition {
+    readonly key: string
+    readonly optional: boolean
+    readonly converter: PropertyTypeConverter<PropertyType>
+}
+
+export type PropertyType = string | number | boolean;
+export type Properties = { [key: string]: PropertyType };
+
+export interface PropertyTypeConverter<T extends PropertyType> {
+    convert(value: unknown): T
+}
+
+export const BOOLEAN = new class implements PropertyTypeConverter<boolean> {
+    convert(value: unknown): boolean {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        else if (typeof value === "string") {
+            return value.toLowerCase() === "true";
+        }
+        throw new Error("Cannot convert value to boolean: " + value);
+    }
+};
+
+export const STRING = new class implements PropertyTypeConverter<string> {
+    convert(value: unknown): string {
+        if (value === undefined) {
+            throw new Error("Cannot convert undefined ");
+        }
+        return String(value);
+    }
+}
+
+export const NUMBER = new class implements PropertyTypeConverter<number> {
+    convert(value: unknown): number {
+        if (value === undefined) {
+            throw new Error("Cannot convert undefined ");
+        }
+        if (typeof value === "object") {
+            throw new Error("Cannot convert object/array to number: " + value);
+        }
+        return Number(value);
+    }
+}
+
+export function property<T extends PropertyType>(name: string, converter: PropertyTypeConverter<T>): PropertyDefinition {
+    return {key: name, optional: true, converter: converter};
+}

package/src/config/index.ts

@@ -0,0 +1 @@
+

package/src/discovery/SimpleDiscoveryNode.ts

@@ -0,0 +1,14 @@
+import {type DiscoveryNode} from './index.ts';
+import {type Address} from '../cluster/Address.ts';
+
+export class SimpleDiscoveryNode implements DiscoveryNode {
+    readonly privateAddress: Address;
+    readonly publicAddress: Address;
+    readonly properties: ReadonlyMap<string, unknown>;
+    constructor(privateAddress: Address, publicAddress?: Address, properties?: ReadonlyMap<string, unknown>)
+    {
+        this.privateAddress = privateAddress;
+        this.publicAddress = publicAddress ?? privateAddress;
+        this.properties = properties ?? new Map();
+    }
+}