@di-framework/bindings 0.0.1 → 6.0.1

package/README.md

@@ -0,0 +1,101 @@
+# @di-framework/bindings
+
+Native [wasmCloud](https://wasmcloud.com) WIT service bindings for DI Framework applications.
+
+Each concrete class is a DI token, a named `hostInterfaces` entry, and a build-time WIT
+requirement. The package maps to wasmCloud/WASI interfaces rather than inventing a second
+capability vocabulary.
+
+This package **consumes** host-interface bindings. It does not provision PostgreSQL, Redis, NATS,
+or object stores, and it never embeds secret values. ConfigMaps and Secrets stay with Pulumi,
+Terraform, Crossplane, Helm, or another infrastructure layer.
+
+## Bindings
+
+```ts
+import { Component, Container } from '@di-framework/core/decorators';
+import { KeyValue, Postgres, WasmCloudBinding } from '@di-framework/bindings';
+
+@WasmCloudBinding('user-database')
+@Container()
+export class UserDatabase extends Postgres {}
+
+@WasmCloudBinding('sessions', { interfaces: ['store', 'atomics'] })
+@Container()
+export class Sessions extends KeyValue {}
+
+@WasmCloudBinding('cache')
+@Container()
+export class Cache extends KeyValue {}
+```
+
+Put those classes in `src/bindings.ts`. The wasmCloud CLI extension discovers the file, contributes
+each class to the shared WIT requirement graph, generates real WIT guest imports, and renders
+matching `hostInterfaces` entries. PostgreSQL entries omit `hostInterfaces[].name` to match the
+unlabeled import; the binding name still identifies the DI guest and its configuration overlays.
+The compiled guest world is unlabeled (`import wasmcloud:postgres/query@0.2.0`) because the qjs componentizer cannot
+emit `cm-implements` labeled imports yet. Imported `async func`s (postgres, key-value, blobstore,
+messaging, secrets, outgoing HTTP) componentize with `@di-framework/componentize-qjs`
+(wasmtime 48). Set `DI_FRAMEWORK_COMPONENTIZE_QJS` to override that CLI.
+`wasi:config@0.2.0-rc.1` is sync and also componentizes with stock jco.
+
+For PostgreSQL, configure the host connection with `WASH_POSTGRES_URL` (or
+`WASMCLOUD_POSTGRES_URL` with the CLI's `platform dev` command), and set
+`config: { database: 'orders' }` on the binding. The unnamed import uses the host's
+connection and the selected database; multiple independently credentialed PostgreSQL
+bindings are not supported by this QuickJS path yet. Guests initialize before the
+application, including bindings constructed at module startup.
+
+Secret material is referenced, never inlined:
+
+```ts
+@WasmCloudBinding('user-database', { secretFrom: 'orders-user-database' })
+@Container()
+export class UserDatabase extends Postgres {}
+```
+
+When `secretFrom` is omitted, the default Kubernetes Secret name is `<application>-<binding>`.
+
+## Supported capabilities
+
+| Class | WIT package | Version |
+| --- | --- | --- |
+| `Postgres` | `wasmcloud:postgres` | 0.2.0 |
+| `KeyValue` | `wasmcloud:keyvalue` | 0.2.0 |
+| `Blobstore` | `wasmcloud:blobstore` | 0.1.0 |
+| `Messaging` | `wasmcloud:messaging` | 0.3.0 |
+| `Config` | `wasi:config` | 0.2.0-rc.1 |
+| `Secrets` | `wasmcloud:secrets` | 2.1.0 |
+| `OutgoingHttp` | `wasi:http` `client` | 0.3.0 |
+
+Package versions are independent of the WASI 0.3 component-model preview.
+
+## Unit tests
+
+Replace a binding through the container:
+
+```ts
+class FakeUserDatabase extends UserDatabase {
+  override query() {
+    return Promise.resolve([]);
+  }
+}
+
+testContainer.registerValue(UserDatabase, new FakeUserDatabase());
+```
+
+## Managed PostgreSQL (upcoming release)
+
+```ts
+@WasmCloudBinding('orders-db', { serviceName: 'orders' })
+export class OrdersDatabase extends Postgres {}
+```
+
+Create the service with `di-framework platform service create postgres --name orders --wait`.
+Deploying creates workload-owned ServiceBindings and waits for the controller's
+connection Secrets. Multiple bindings can share a service; separate services use
+independent credentials and PVCs. `serviceName` currently supports PostgreSQL only
+and cannot be combined with manual connection configuration.
+
+See [platform PostgreSQL lifecycle and recovery](../di-framework-platform/README.md#dedicated-postgresql-upcoming-release)
+for storage prerequisites, retention, and deletion.

package/catalog.json

@@ -0,0 +1,86 @@
+{
+  "Postgres": {
+    "kind": "Postgres",
+    "package": "wasmcloud:postgres",
+    "version": "0.2.0",
+    "interfaces": ["query", "prepared", "types"],
+    "primaryInterface": "query",
+    "namedInstance": true,
+    "sharedResources": ["types.pg-value", "types.error"],
+    "witDep": "wasmcloud-postgres",
+    "usesSecret": true,
+    "configKeys": []
+  },
+  "KeyValue": {
+    "kind": "KeyValue",
+    "package": "wasmcloud:keyvalue",
+    "version": "0.2.0",
+    "interfaces": ["store", "atomics", "cas", "batch", "types"],
+    "primaryInterface": "store",
+    "namedInstance": true,
+    "sharedResources": ["types.bucket", "types.error"],
+    "witDep": "wasmcloud-keyvalue",
+    "usesSecret": false,
+    "configKeys": ["backend", "url", "prefix", "root"]
+  },
+  "Blobstore": {
+    "kind": "Blobstore",
+    "package": "wasmcloud:blobstore",
+    "version": "0.1.0",
+    "interfaces": ["blobstore", "container", "types"],
+    "primaryInterface": "blobstore",
+    "namedInstance": true,
+    "sharedResources": ["types.container", "types.error"],
+    "witDep": "wasmcloud-blobstore",
+    "usesSecret": false,
+    "configKeys": ["backend", "url", "root", "buckets"]
+  },
+  "Messaging": {
+    "kind": "Messaging",
+    "package": "wasmcloud:messaging",
+    "version": "0.3.0",
+    "interfaces": ["consumer", "types"],
+    "primaryInterface": "consumer",
+    "namedInstance": true,
+    "sharedResources": ["types.broker-message", "types.error"],
+    "witDep": "wasmcloud-messaging",
+    "usesSecret": false,
+    "configKeys": ["backend", "url", "subscriptions", "consumer_group"]
+  },
+  "Config": {
+    "kind": "Config",
+    "package": "wasi:config",
+    "version": "0.2.0-rc.1",
+    "interfaces": ["store"],
+    "primaryInterface": "store",
+    "namedInstance": false,
+    "sharedResources": [],
+    "witDep": "wasi-config",
+    "usesSecret": false,
+    "configKeys": []
+  },
+  "Secrets": {
+    "kind": "Secrets",
+    "package": "wasmcloud:secrets",
+    "version": "2.1.0",
+    "interfaces": ["store", "reveal"],
+    "primaryInterface": "store",
+    "namedInstance": true,
+    "sharedResources": [],
+    "witDep": "wasmcloud-secrets",
+    "usesSecret": true,
+    "configKeys": []
+  },
+  "OutgoingHttp": {
+    "kind": "OutgoingHttp",
+    "package": "wasi:http",
+    "version": "0.3.0",
+    "interfaces": ["client"],
+    "primaryInterface": "client",
+    "namedInstance": false,
+    "sharedResources": [],
+    "witDep": "wasi-http",
+    "usesSecret": false,
+    "configKeys": ["allowedHosts"]
+  }
+}

package/dist/bindings/blobstore.d.ts

@@ -0,0 +1,11 @@
+export type BlobstoreGuest = {
+    createContainer(name: string): Promise<unknown>;
+    getContainer(name: string): Promise<unknown>;
+};
+export declare class Blobstore {
+    readonly bindingName: string;
+    protected readonly guest: BlobstoreGuest | undefined;
+    constructor(guest?: BlobstoreGuest);
+    createContainer(name: string): Promise<unknown>;
+    getContainer(name: string): Promise<unknown>;
+}

package/dist/bindings/blobstore.js

@@ -0,0 +1,16 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class Blobstore {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'blobstore';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    createContainer(name) {
+        return requireGuest(this.guest, this.bindingName).createContainer(name);
+    }
+    getContainer(name) {
+        return requireGuest(this.guest, this.bindingName).getContainer(name);
+    }
+}

package/dist/bindings/config.d.ts

@@ -0,0 +1,11 @@
+export type ConfigGuest = {
+    get(key: string): Promise<string | undefined> | string | undefined;
+    getAll(): Promise<Array<[string, string]>> | Array<[string, string]>;
+};
+export declare class Config {
+    readonly bindingName: string;
+    protected readonly guest: ConfigGuest | undefined;
+    constructor(guest?: ConfigGuest);
+    get(key: string): Promise<string | undefined> | string | undefined;
+    getAll(): Promise<Array<[string, string]>> | Array<[string, string]>;
+}

package/dist/bindings/config.js

@@ -0,0 +1,16 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class Config {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'config';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    get(key) {
+        return requireGuest(this.guest, this.bindingName).get(key);
+    }
+    getAll() {
+        return requireGuest(this.guest, this.bindingName).getAll();
+    }
+}

package/dist/bindings/keyvalue.d.ts

@@ -0,0 +1,9 @@
+export type KeyValueGuest = {
+    open(identifier: string): Promise<unknown>;
+};
+export declare class KeyValue {
+    readonly bindingName: string;
+    protected readonly guest: KeyValueGuest | undefined;
+    constructor(guest?: KeyValueGuest);
+    open(identifier: string): Promise<unknown>;
+}

package/dist/bindings/keyvalue.js

@@ -0,0 +1,13 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class KeyValue {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'keyvalue';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    open(identifier) {
+        return requireGuest(this.guest, this.bindingName).open(identifier);
+    }
+}

package/dist/bindings/messaging.d.ts

@@ -0,0 +1,11 @@
+export type MessagingGuest = {
+    publish(message: unknown): Promise<unknown>;
+    request(subject: string, body: AsyncIterable<Uint8Array>, timeoutMs?: number): Promise<unknown>;
+};
+export declare class Messaging {
+    readonly bindingName: string;
+    protected readonly guest: MessagingGuest | undefined;
+    constructor(guest?: MessagingGuest);
+    publish(message: unknown): Promise<unknown>;
+    request(subject: string, body: AsyncIterable<Uint8Array>, timeoutMs?: number): Promise<unknown>;
+}

package/dist/bindings/messaging.js

@@ -0,0 +1,16 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class Messaging {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'messaging';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    publish(message) {
+        return requireGuest(this.guest, this.bindingName).publish(message);
+    }
+    request(subject, body, timeoutMs) {
+        return requireGuest(this.guest, this.bindingName).request(subject, body, timeoutMs);
+    }
+}

package/dist/bindings/outgoing-http.d.ts

@@ -0,0 +1,9 @@
+export type OutgoingHttpGuest = {
+    send(request: unknown): Promise<unknown>;
+};
+export declare class OutgoingHttp {
+    readonly bindingName: string;
+    protected readonly guest: OutgoingHttpGuest | undefined;
+    constructor(guest?: OutgoingHttpGuest);
+    send(request: unknown): Promise<unknown>;
+}

package/dist/bindings/outgoing-http.js

@@ -0,0 +1,13 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class OutgoingHttp {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'outgoing-http';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    send(request) {
+        return requireGuest(this.guest, this.bindingName).send(request);
+    }
+}

package/dist/bindings/postgres.d.ts

@@ -0,0 +1,11 @@
+export type PostgresGuest = {
+    query(query: string, params: readonly unknown[]): Promise<unknown>;
+    queryBatch(query: string): Promise<unknown>;
+};
+export declare class Postgres {
+    readonly bindingName: string;
+    protected readonly guest: PostgresGuest | undefined;
+    constructor(guest?: PostgresGuest);
+    query(query: string, params?: readonly unknown[]): Promise<unknown>;
+    queryBatch(query: string): Promise<unknown>;
+}

package/dist/bindings/postgres.js

@@ -0,0 +1,16 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class Postgres {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'postgres';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    query(query, params = []) {
+        return requireGuest(this.guest, this.bindingName).query(query, params);
+    }
+    queryBatch(query) {
+        return requireGuest(this.guest, this.bindingName).queryBatch(query);
+    }
+}

package/dist/bindings/secrets.d.ts

@@ -0,0 +1,11 @@
+export type SecretsGuest = {
+    get(key: string): Promise<unknown>;
+    reveal(secret: unknown): Promise<unknown>;
+};
+export declare class Secrets {
+    readonly bindingName: string;
+    protected readonly guest: SecretsGuest | undefined;
+    constructor(guest?: SecretsGuest);
+    get(key: string): Promise<unknown>;
+    reveal(secret: unknown): Promise<unknown>;
+}

package/dist/bindings/secrets.js

@@ -0,0 +1,16 @@
+import { requireGuest, tryGetGuest } from '../guests.js';
+import { getBindingMetadata } from '../metadata.js';
+export class Secrets {
+    bindingName;
+    guest;
+    constructor(guest) {
+        this.bindingName = getBindingMetadata(this.constructor)?.name ?? 'secrets';
+        this.guest = guest ?? tryGetGuest(this.bindingName);
+    }
+    get(key) {
+        return requireGuest(this.guest, this.bindingName).get(key);
+    }
+    reveal(secret) {
+        return requireGuest(this.guest, this.bindingName).reveal(secret);
+    }
+}

package/dist/catalog.d.ts

@@ -0,0 +1,17 @@
+export declare const BINDING_KINDS: readonly ["Postgres", "KeyValue", "Blobstore", "Messaging", "Config", "Secrets", "OutgoingHttp"];
+export type BindingKind = (typeof BINDING_KINDS)[number];
+export type CatalogEntry = {
+    kind: BindingKind;
+    package: string;
+    version: string;
+    interfaces: string[];
+    /** First interface carries the labeled import / hostInterfaces name. */
+    primaryInterface: string;
+    namedInstance: boolean;
+    sharedResources: string[];
+    witDep: string;
+    usesSecret: boolean;
+    configKeys: string[];
+};
+export declare const BINDING_CATALOG: Record<BindingKind, CatalogEntry>;
+export declare function isBindingKind(value: string): value is BindingKind;

package/dist/catalog.js

@@ -0,0 +1,98 @@
+export const BINDING_KINDS = [
+    'Postgres',
+    'KeyValue',
+    'Blobstore',
+    'Messaging',
+    'Config',
+    'Secrets',
+    'OutgoingHttp',
+];
+export const BINDING_CATALOG = {
+    Postgres: {
+        kind: 'Postgres',
+        package: 'wasmcloud:postgres',
+        version: '0.2.0',
+        interfaces: ['query', 'prepared', 'types'],
+        primaryInterface: 'query',
+        namedInstance: true,
+        sharedResources: ['types.pg-value', 'types.error'],
+        witDep: 'wasmcloud-postgres',
+        usesSecret: true,
+        configKeys: [],
+    },
+    KeyValue: {
+        kind: 'KeyValue',
+        package: 'wasmcloud:keyvalue',
+        version: '0.2.0',
+        interfaces: ['store', 'atomics', 'cas', 'batch', 'types'],
+        primaryInterface: 'store',
+        namedInstance: true,
+        sharedResources: ['types.bucket', 'types.error'],
+        witDep: 'wasmcloud-keyvalue',
+        usesSecret: false,
+        configKeys: ['backend', 'url', 'prefix', 'root'],
+    },
+    Blobstore: {
+        kind: 'Blobstore',
+        package: 'wasmcloud:blobstore',
+        version: '0.1.0',
+        interfaces: ['blobstore', 'container', 'types'],
+        primaryInterface: 'blobstore',
+        namedInstance: true,
+        sharedResources: ['types.container', 'types.error'],
+        witDep: 'wasmcloud-blobstore',
+        usesSecret: false,
+        configKeys: ['backend', 'url', 'root', 'buckets'],
+    },
+    Messaging: {
+        kind: 'Messaging',
+        package: 'wasmcloud:messaging',
+        version: '0.3.0',
+        interfaces: ['consumer', 'types'],
+        primaryInterface: 'consumer',
+        namedInstance: true,
+        sharedResources: ['types.broker-message', 'types.error'],
+        witDep: 'wasmcloud-messaging',
+        usesSecret: false,
+        configKeys: ['backend', 'url', 'subscriptions', 'consumer_group'],
+    },
+    Config: {
+        kind: 'Config',
+        package: 'wasi:config',
+        version: '0.2.0-rc.1',
+        interfaces: ['store'],
+        primaryInterface: 'store',
+        namedInstance: false,
+        sharedResources: [],
+        witDep: 'wasi-config',
+        usesSecret: false,
+        configKeys: [],
+    },
+    Secrets: {
+        kind: 'Secrets',
+        package: 'wasmcloud:secrets',
+        version: '2.1.0',
+        interfaces: ['store', 'reveal'],
+        primaryInterface: 'store',
+        namedInstance: true,
+        sharedResources: [],
+        witDep: 'wasmcloud-secrets',
+        usesSecret: true,
+        configKeys: [],
+    },
+    OutgoingHttp: {
+        kind: 'OutgoingHttp',
+        package: 'wasi:http',
+        version: '0.3.0',
+        interfaces: ['client'],
+        primaryInterface: 'client',
+        namedInstance: false,
+        sharedResources: [],
+        witDep: 'wasi-http',
+        usesSecret: false,
+        configKeys: ['allowedHosts'],
+    },
+};
+export function isBindingKind(value) {
+    return BINDING_KINDS.includes(value);
+}

package/dist/decorator.d.ts

@@ -0,0 +1,9 @@
+import { type WasmCloudBindingOptions } from './metadata.js';
+export type { WasmCloudBindingOptions };
+/**
+ * Declares a named wasmCloud host-interface binding on a concrete class.
+ * Class identity is the DI token; `name` is the WIT import and hostInterfaces name.
+ */
+export declare function WasmCloudBinding(name: string, options?: WasmCloudBindingOptions): <T extends {
+    new (...args: any[]): object;
+}>(ctor: T) => T;

package/dist/decorator.js

@@ -0,0 +1,34 @@
+import { Postgres } from './bindings/postgres.js';
+import { defineBindingMetadata, isWitIdentifier, rejectsPlaintextSecret, } from './metadata.js';
+/**
+ * Declares a named wasmCloud host-interface binding on a concrete class.
+ * Class identity is the DI token; `name` is the WIT import and hostInterfaces name.
+ */
+export function WasmCloudBinding(name, options = {}) {
+    // biome-ignore lint/suspicious/noExplicitAny: class decorator constructor
+    return (ctor) => {
+        if (!isWitIdentifier(name)) {
+            throw new Error(`WasmCloud binding name "${name}" must be a WIT identifier matching /^[a-z][a-z0-9-]*$/`);
+        }
+        if (options.serviceName !== undefined) {
+            if (typeof options.serviceName !== 'string' ||
+                !/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(options.serviceName) ||
+                options.serviceName.length > 40)
+                throw new Error('serviceName must be a DNS label of at most 40 characters');
+            if (!(ctor.prototype instanceof Postgres))
+                throw new Error('serviceName is currently supported only for Postgres');
+            if (options.config !== undefined ||
+                options.configFrom !== undefined ||
+                options.secretFrom !== undefined)
+                throw new Error('serviceName cannot be combined with manual connection configuration');
+            if (name.length > 54 || !/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name))
+                throw new Error('Managed PostgreSQL binding names must be DNS labels of at most 54 characters');
+        }
+        const secretProblem = rejectsPlaintextSecret(options.config);
+        if (secretProblem !== undefined) {
+            throw new Error(`WasmCloud binding "${name}": ${secretProblem}`);
+        }
+        defineBindingMetadata(ctor, { name, options });
+        return ctor;
+    };
+}

package/dist/guests.d.ts

@@ -0,0 +1,7 @@
+export type GuestModules = Record<string, unknown>;
+/** Well-known key the wasmCloud CLI plugin writes from generated `guests.js`. */
+export declare const WASMCLOUD_GUESTS_GLOBAL = "di-framework.wasmcloud.guests";
+export declare function setGuests(value: GuestModules): void;
+export declare function resetGuests(): void;
+export declare function tryGetGuest<T>(name: string): T | undefined;
+export declare function requireGuest<T>(guest: T | undefined, name: string): T;

package/dist/guests.js

@@ -0,0 +1,24 @@
+/** Well-known key the wasmCloud CLI plugin writes from generated `guests.js`. */
+export const WASMCLOUD_GUESTS_GLOBAL = 'di-framework.wasmcloud.guests';
+const GUESTS_KEY = Symbol.for(WASMCLOUD_GUESTS_GLOBAL);
+let guests = {};
+function installedGuests() {
+    return globalThis[GUESTS_KEY] ?? guests;
+}
+export function setGuests(value) {
+    guests = value;
+    globalThis[GUESTS_KEY] = value;
+}
+export function resetGuests() {
+    guests = {};
+    delete globalThis[GUESTS_KEY];
+}
+export function tryGetGuest(name) {
+    return installedGuests()[name];
+}
+export function requireGuest(guest, name) {
+    if (guest === undefined) {
+        throw new Error(`wasmCloud binding "${name}" has no guest implementation. In unit tests, pass a fake to the constructor or call setGuests().`);
+    }
+    return guest;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { Blobstore, type BlobstoreGuest } from './bindings/blobstore.js';
+export { Config, type ConfigGuest } from './bindings/config.js';
+export { KeyValue, type KeyValueGuest } from './bindings/keyvalue.js';
+export { Messaging, type MessagingGuest } from './bindings/messaging.js';
+export { OutgoingHttp, type OutgoingHttpGuest } from './bindings/outgoing-http.js';
+export { Postgres, type PostgresGuest } from './bindings/postgres.js';
+export { Secrets, type SecretsGuest } from './bindings/secrets.js';
+export { BINDING_CATALOG, BINDING_KINDS, type BindingKind, type CatalogEntry, isBindingKind, } from './catalog.js';
+export { WasmCloudBinding, type WasmCloudBindingOptions } from './decorator.js';
+export { type GuestModules, resetGuests, setGuests, tryGetGuest, WASMCLOUD_GUESTS_GLOBAL, } from './guests.js';
+export { getBindingMetadata, isWitIdentifier, WASMCLOUD_BINDING_KEY, type WasmCloudBindingMetadata, } from './metadata.js';
+export { getWorkload, getWorkloadComponent, getWorkloadService, WORKLOAD_COMPONENT_KEY, WORKLOAD_KEY, WORKLOAD_SERVICE_KEY, Workload, WorkloadComponent, type WorkloadComponentOptions, type WorkloadFetchHandler, type WorkloadMetadata, type WorkloadRunHandler, WorkloadService, type WorkloadServiceOptions, } from './workload.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export { Blobstore } from './bindings/blobstore.js';
+export { Config } from './bindings/config.js';
+export { KeyValue } from './bindings/keyvalue.js';
+export { Messaging } from './bindings/messaging.js';
+export { OutgoingHttp } from './bindings/outgoing-http.js';
+export { Postgres } from './bindings/postgres.js';
+export { Secrets } from './bindings/secrets.js';
+export { BINDING_CATALOG, BINDING_KINDS, isBindingKind, } from './catalog.js';
+export { WasmCloudBinding } from './decorator.js';
+export { resetGuests, setGuests, tryGetGuest, WASMCLOUD_GUESTS_GLOBAL, } from './guests.js';
+export { getBindingMetadata, isWitIdentifier, WASMCLOUD_BINDING_KEY, } from './metadata.js';
+export { getWorkload, getWorkloadComponent, getWorkloadService, WORKLOAD_COMPONENT_KEY, WORKLOAD_KEY, WORKLOAD_SERVICE_KEY, Workload, WorkloadComponent, WorkloadService, } from './workload.js';

package/dist/metadata.d.ts

@@ -0,0 +1,17 @@
+export declare const WASMCLOUD_BINDING_KEY = "di:wasmcloud-binding";
+export type WasmCloudBindingOptions = {
+    /** Same-namespace managed PostgreSQL BackingService. */
+    serviceName?: string;
+    interfaces?: string[];
+    secretFrom?: string;
+    configFrom?: string;
+    config?: Record<string, string>;
+};
+export type WasmCloudBindingMetadata = {
+    name: string;
+    options: WasmCloudBindingOptions;
+};
+export declare function isWitIdentifier(name: string): boolean;
+export declare function rejectsPlaintextSecret(config: Record<string, string> | undefined): string | undefined;
+export declare function defineBindingMetadata(target: object, metadata: WasmCloudBindingMetadata): void;
+export declare function getBindingMetadata(target: object): WasmCloudBindingMetadata | undefined;

package/dist/metadata.js

@@ -0,0 +1,33 @@
+import { defineMetadata, getOwnMetadata } from '@di-framework/core/container';
+export const WASMCLOUD_BINDING_KEY = 'di:wasmcloud-binding';
+const SECRET_CONFIG_KEYS = new Set([
+    'password',
+    'secret',
+    'token',
+    'uri',
+    'url',
+    'connectionstring',
+    'connection-string',
+]);
+export function isWitIdentifier(name) {
+    return /^[a-z][a-z0-9-]*$/.test(name);
+}
+export function rejectsPlaintextSecret(config) {
+    if (config === undefined)
+        return undefined;
+    for (const [key, value] of Object.entries(config)) {
+        if (SECRET_CONFIG_KEYS.has(key.toLowerCase())) {
+            return `config key "${key}" must not carry a secret value; use secretFrom`;
+        }
+        if (/:\/\//.test(value) || /password=/i.test(value)) {
+            return `config value for "${key}" looks like a secret or connection string; use secretFrom`;
+        }
+    }
+    return undefined;
+}
+export function defineBindingMetadata(target, metadata) {
+    defineMetadata(WASMCLOUD_BINDING_KEY, metadata, target);
+}
+export function getBindingMetadata(target) {
+    return getOwnMetadata(WASMCLOUD_BINDING_KEY, target);
+}

package/dist/workload.d.ts

@@ -0,0 +1,40 @@
+export declare const WORKLOAD_KEY = "di:workload";
+export declare const WORKLOAD_COMPONENT_KEY = "di:workload-component";
+export declare const WORKLOAD_SERVICE_KEY = "di:workload-service";
+export type WorkloadFetchHandler = (request: Request) => Response | Promise<Response>;
+export type WorkloadRunHandler = () => Promise<void>;
+export type WorkloadMetadata = {
+    name: string;
+};
+export type WorkloadComponentOptions = {
+    /** Optional legacy assertion; deployment membership comes from di-framework.config.json. */
+    workload?: string;
+    /** Path identifying this component within its implicit workload. */
+    path: string;
+};
+export type WorkloadServiceOptions = {
+    /** Path identifying this service within its implicit workload. */
+    path: string;
+    /** Optional legacy assertion; deployment membership comes from di-framework.config.json. */
+    workload?: string;
+    /** Broker subjects delivered to this service by the host. */
+    subscriptions?: string[];
+};
+/**
+ * Names a colocation namespace. Not an HTTP gateway and not a deployable.
+ * Components and services join it via {@link WorkloadComponent} / {@link WorkloadService}.
+ */
+export declare function Workload(name: string): <T extends object>(target: T) => T;
+/**
+ * Describes an independently deployed component in an implicit workload.
+ * `path` identifies the member and is its HTTP route in the generated manifest.
+ */
+export declare function WorkloadComponent(options: WorkloadComponentOptions): <T extends object>(target: T) => T;
+/**
+ * Describes a service in an implicit workload. The host invokes broker subscriptions
+ * when declared; otherwise the service exports a CLI run entrypoint.
+ */
+export declare function WorkloadService(options: WorkloadServiceOptions): <T extends object>(target: T) => T;
+export declare function getWorkload(target: object): WorkloadMetadata | undefined;
+export declare function getWorkloadComponent(target: object): WorkloadComponentOptions | undefined;
+export declare function getWorkloadService(target: object): WorkloadServiceOptions | undefined;

package/dist/workload.js

@@ -0,0 +1,71 @@
+import { defineMetadata, getOwnMetadata } from '@di-framework/core/container';
+export const WORKLOAD_KEY = 'di:workload';
+export const WORKLOAD_COMPONENT_KEY = 'di:workload-component';
+export const WORKLOAD_SERVICE_KEY = 'di:workload-service';
+function requireName(kind, name) {
+    if (!name.trim()) {
+        throw new Error(`${kind} name is required`);
+    }
+    return name;
+}
+/**
+ * Names a colocation namespace. Not an HTTP gateway and not a deployable.
+ * Components and services join it via {@link WorkloadComponent} / {@link WorkloadService}.
+ */
+export function Workload(name) {
+    const metadata = { name: requireName('Workload', name) };
+    return (target) => {
+        defineMetadata(WORKLOAD_KEY, metadata, target);
+        return target;
+    };
+}
+function requirePath(kind, path) {
+    if (typeof path !== 'string' ||
+        !path.startsWith('/') ||
+        path.startsWith('//') ||
+        /[\s?#\\]/.test(path)) {
+        throw new Error(`${kind} path is required and must be an absolute path starting with "/"`);
+    }
+    return path;
+}
+/**
+ * Describes an independently deployed component in an implicit workload.
+ * `path` identifies the member and is its HTTP route in the generated manifest.
+ */
+export function WorkloadComponent(options) {
+    const metadata = {
+        ...(options.workload === undefined
+            ? {}
+            : { workload: requireName('WorkloadComponent', options.workload) }),
+        path: requirePath('WorkloadComponent', options.path),
+    };
+    return (target) => {
+        defineMetadata(WORKLOAD_COMPONENT_KEY, metadata, target);
+        return target;
+    };
+}
+/**
+ * Describes a service in an implicit workload. The host invokes broker subscriptions
+ * when declared; otherwise the service exports a CLI run entrypoint.
+ */
+export function WorkloadService(options) {
+    const workload = options.workload === undefined ? undefined : requireName('WorkloadService', options.workload);
+    const path = requirePath('WorkloadService', options.path);
+    return (target) => {
+        defineMetadata(WORKLOAD_SERVICE_KEY, {
+            ...(workload === undefined ? {} : { workload }),
+            path,
+            ...(options.subscriptions ? { subscriptions: [...options.subscriptions] } : {}),
+        }, target);
+        return target;
+    };
+}
+export function getWorkload(target) {
+    return getOwnMetadata(WORKLOAD_KEY, target);
+}
+export function getWorkloadComponent(target) {
+    return getOwnMetadata(WORKLOAD_COMPONENT_KEY, target);
+}
+export function getWorkloadService(target) {
+    return getOwnMetadata(WORKLOAD_SERVICE_KEY, target);
+}

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@di-framework/bindings",
-  "version": "0.0.1",
-  "description": "Placeholder for di-framework platform app bindings.",
+  "version": "6.0.1",
+  "description": "Native platform WIT service bindings for DI Framework applications.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "license": "(MIT OR Apache-2.0)",
   "author": "@di-framework Contributors",
@@ -10,13 +13,42 @@
     "url": "https://github.com/di-framework/platform",
     "directory": "platform/bindings"
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "bugs": {
+    "url": "https://github.com/di-framework/platform/issues"
+  },
+  "homepage": "https://github.com/di-framework/platform",
+  "keywords": [
+    "wasmcloud",
+    "wasi",
+    "wit",
+    "webassembly",
+    "dependency-injection",
+    "decorators"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "build": "rm -rf dist && bun x tsc -p tsconfig.build.json && bun ../../scripts/fix-esm-imports.ts dist"
+  },
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./catalog.json": "./catalog.json"
+  },
+  "peerDependencies": {
+    "@di-framework/core": "^5",
+    "typescript": "^5"
   },
-  "files": ["src"],
-  "publishConfig": {
-    "access": "public"
+  "files": [
+    "dist",
+    "catalog.json",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@di-framework/core": "^5",
+    "@types/bun": "latest"
   }
 }

package/src/index.ts

@@ -1,2 +0,0 @@
-/** Placeholder. Implementation ships from di-framework/platform. */
-export const name = "@di-framework/bindings" as const;