@di-framework/cloudfoundry 5.2.3

package/README.md

@@ -0,0 +1,128 @@
+# @di-framework/cloudfoundry
+
+Cloud Foundry connector for `@di-framework` — automatic `VCAP_SERVICES` and `VCAP_APPLICATION` discovery, strongly typed ServiceInfo models, SPI creator extensible registry, and automated DI bindings.
+
+Inspired by Spring Cloud Connectors (`spring-cloud-cloudfoundry-connector`), this package streamlines running `@di-framework` applications on Cloud Foundry and Tanzu Application Service.
+
+## Features
+
+- **Automatic Environment Detection**: Fast detection via `CloudFoundryDetector` and `isCloudFoundry()`.
+- **Application Info Parsing**: Strongly typed `CloudFoundryApplicationInfo` containing application names, URIs, instance index, space, limits, etc.
+- **Service Info Creators (SPI)**: Extensible discovery and normalized models for:
+  - **Relational Databases**: PostgreSQL, MySQL, MariaDB, SQLite (`RelationalServiceInfo`)
+  - **Redis / Cache**: Redis standalone, TLS, cluster (`RedisServiceInfo`)
+  - **AMQP / Message Brokers**: RabbitMQ, CloudAMQP (`AmqpServiceInfo`)
+  - **Blob Storage / S3**: MinIO, AWS S3, Object Store (`BlobStorageServiceInfo`)
+  - **User-Provided Services**: `cf cups` custom services (`UserProvidedServiceInfo`)
+- **DI & Decorator Integration**:
+  - `@CloudFoundryService('service-name')` for parameter and property injection
+  - `@VcapApplication()` for application metadata injection
+  - `@EnableCloudFoundryConnectors()` for container-wide auto-wiring
+- **Local Fallback**: Automatically falls back to standard local environment variables (`DATABASE_URL`, `REDIS_URL`, `AMQP_URL`, `S3_BUCKET`) when running outside Cloud Foundry.
+
+## Installation
+
+```bash
+bun add @di-framework/cloudfoundry
+```
+
+## Quick Start
+
+### 1. Using `@EnableCloudFoundryConnectors` and `@CloudFoundryService`
+
+```typescript
+import { Container } from '@di-framework/core/decorators';
+import {
+  CloudFoundryService,
+  EnableCloudFoundryConnectors,
+  RelationalServiceInfo,
+  RedisServiceInfo,
+  VcapApplication,
+  CloudFoundryApplicationInfo,
+} from '@di-framework/cloudfoundry';
+
+@EnableCloudFoundryConnectors()
+@Container()
+export class ApplicationService {
+  @VcapApplication()
+  private appInfo!: CloudFoundryApplicationInfo;
+
+  @CloudFoundryService('my-postgres-db')
+  private dbService!: RelationalServiceInfo;
+
+  @CloudFoundryService('my-redis-cache')
+  private redisService!: RedisServiceInfo;
+
+  start() {
+    console.log(`Running app ${this.appInfo?.applicationName}`);
+    console.log(`Database URI: ${this.dbService.uri}`);
+    console.log(`Redis host: ${this.redisService.host}:${this.redisService.port}`);
+  }
+}
+```
+
+### 2. Programmatic Discovery via `CloudFoundryEnvironment`
+
+```typescript
+import { CloudFoundryEnvironment } from '@di-framework/cloudfoundry';
+
+const cfEnv = new CloudFoundryEnvironment();
+
+if (cfEnv.isCloudFoundry()) {
+  const appInfo = cfEnv.getApplicationInfo();
+  console.log(`Space: ${appInfo?.spaceName}, Instance: ${appInfo?.instanceIndex}`);
+
+  // Retrieve primary relational database
+  const db = cfEnv.getRelationalServiceInfo();
+  if (db) {
+    console.log(`Connected to ${db.dialect} at ${db.host}:${db.port}/${db.database}`);
+  }
+
+  // Retrieve Redis service
+  const redis = cfEnv.getRedisServiceInfo();
+  if (redis) {
+    console.log(`Redis URI: ${redis.uri}`);
+  }
+}
+```
+
+### 3. Custom Service Creators (SPI)
+
+You can register custom service info creators with `ServiceInfoCreatorRegistry`:
+
+```typescript
+import {
+  CloudFoundryServiceInfoCreator,
+  getDefaultRegistry,
+  RawVcapServiceData,
+  CloudFoundryServiceInfo,
+} from '@di-framework/cloudfoundry';
+
+export interface ElasticsearchServiceInfo extends CloudFoundryServiceInfo {
+  readonly uri: string;
+}
+
+export class ElasticsearchServiceInfoCreator implements CloudFoundryServiceInfoCreator<ElasticsearchServiceInfo> {
+  accept(data: RawVcapServiceData): boolean {
+    return data.label.includes('elasticsearch') || (data.tags || []).includes('elasticsearch');
+  }
+
+  createServiceInfo(data: RawVcapServiceData): ElasticsearchServiceInfo {
+    const creds = data.credentials || {};
+    return {
+      id: data.name,
+      name: data.name,
+      label: data.label,
+      tags: [...(data.tags || [])],
+      credentials: creds,
+      uri: String(creds.uri ?? 'http://localhost:9200'),
+    };
+  }
+}
+
+getDefaultRegistry().registerCreator(new ElasticsearchServiceInfoCreator());
+```
+
+## License
+
+Licensed under either [MIT](../../LICENSE-MIT) or [Apache-2.0](../../LICENSE-APACHE), at your option.

package/dist/application-info.d.ts

@@ -0,0 +1,6 @@
+import type { CloudFoundryApplicationInfo } from './types.js';
+/**
+ * Parses VCAP_APPLICATION JSON string, object payload, or process environment
+ * into a strongly typed CloudFoundryApplicationInfo model.
+ */
+export declare function parseVcapApplication(input?: string | Record<string, unknown>): CloudFoundryApplicationInfo | null;

package/dist/application-info.js

@@ -0,0 +1,126 @@
+import { CloudFoundryDetector } from './detector.js';
+/**
+ * Parses VCAP_APPLICATION JSON string, object payload, or process environment
+ * into a strongly typed CloudFoundryApplicationInfo model.
+ */
+export function parseVcapApplication(input) {
+    if (input === null)
+        return null;
+    let rawObj = null;
+    if (input === undefined) {
+        const rawEnv = CloudFoundryDetector.getApplicationJson();
+        if (!rawEnv)
+            return null;
+        try {
+            rawObj = JSON.parse(rawEnv);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (typeof input === 'string') {
+        try {
+            rawObj = JSON.parse(input);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (typeof input === 'object') {
+        if ('VCAP_APPLICATION' in input) {
+            const vcapVal = input.VCAP_APPLICATION;
+            if (typeof vcapVal === 'string' && vcapVal.trim().length > 0) {
+                try {
+                    rawObj = JSON.parse(vcapVal);
+                }
+                catch {
+                    return null;
+                }
+            }
+            else if (typeof vcapVal === 'object' && vcapVal !== null) {
+                rawObj = vcapVal;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            // Validate that the object actually has VCAP application fields
+            const hasAppFields = 'application_id' in input ||
+                'applicationId' in input ||
+                'app_id' in input ||
+                'application_name' in input ||
+                'applicationName' in input ||
+                'space_id' in input ||
+                'spaceId' in input ||
+                'space_name' in input ||
+                'spaceName' in input;
+            if (!hasAppFields) {
+                return null;
+            }
+            rawObj = input;
+        }
+    }
+    if (!rawObj || typeof rawObj !== 'object') {
+        return null;
+    }
+    const applicationId = String(rawObj.application_id ?? rawObj.applicationId ?? rawObj.app_id ?? '');
+    const applicationName = String(rawObj.application_name ?? rawObj.applicationName ?? rawObj.name ?? '');
+    const rawUris = rawObj.application_uris ?? rawObj.applicationUris ?? rawObj.uris ?? [];
+    const applicationUris = Array.isArray(rawUris)
+        ? rawUris.map(String)
+        : typeof rawUris === 'string'
+            ? [rawUris]
+            : [];
+    const applicationVersion = rawObj.application_version ?? rawObj.applicationVersion ?? rawObj.version;
+    const spaceId = String(rawObj.space_id ?? rawObj.spaceId ?? '');
+    const spaceName = String(rawObj.space_name ?? rawObj.spaceName ?? '');
+    const organizationId = rawObj.organization_id ?? rawObj.organizationId ?? rawObj.org_id;
+    const organizationName = rawObj.organization_name ?? rawObj.organizationName ?? rawObj.org_name;
+    const instanceId = rawObj.instance_id ?? rawObj.instanceId;
+    let instanceIndex;
+    const rawIdx = rawObj.instance_index ?? rawObj.instanceIndex;
+    if (typeof rawIdx === 'number') {
+        instanceIndex = rawIdx;
+    }
+    else if (typeof rawIdx === 'string' && rawIdx.trim().length > 0) {
+        const parsed = parseInt(rawIdx, 10);
+        if (!Number.isNaN(parsed))
+            instanceIndex = parsed;
+    }
+    const host = typeof rawObj.host === 'string' ? rawObj.host : undefined;
+    let port;
+    if (typeof rawObj.port === 'number') {
+        port = rawObj.port;
+    }
+    else if (typeof rawObj.port === 'string' && rawObj.port.trim().length > 0) {
+        const parsed = parseInt(rawObj.port, 10);
+        if (!Number.isNaN(parsed))
+            port = parsed;
+    }
+    let limits;
+    if (typeof rawObj.limits === 'object' && rawObj.limits !== null) {
+        const rawLimits = rawObj.limits;
+        limits = {
+            disk: typeof rawLimits.disk === 'number' ? rawLimits.disk : undefined,
+            fds: typeof rawLimits.fds === 'number' ? rawLimits.fds : undefined,
+            mem: typeof rawLimits.mem === 'number' ? rawLimits.mem : undefined,
+        };
+    }
+    return {
+        applicationId,
+        applicationName,
+        applicationUris,
+        ...(applicationVersion !== undefined ? { applicationVersion: String(applicationVersion) } : {}),
+        spaceId,
+        spaceName,
+        ...(organizationId !== undefined ? { organizationId: String(organizationId) } : {}),
+        ...(organizationName !== undefined ? { organizationName: String(organizationName) } : {}),
+        ...(instanceId !== undefined ? { instanceId: String(instanceId) } : {}),
+        ...(instanceIndex !== undefined ? { instanceIndex } : {}),
+        ...(host !== undefined ? { host } : {}),
+        ...(port !== undefined ? { port } : {}),
+        ...(limits !== undefined ? { limits } : {}),
+        rawConfig: Object.freeze({ ...rawObj }),
+    };
+}

package/dist/bindings.d.ts

@@ -0,0 +1,9 @@
+import { CloudFoundryEnvironment } from './environment.js';
+import type { EnableCloudFoundryConnectorsOptions } from './types.js';
+export declare const CF_ENVIRONMENT_TOKEN = "cf:environment";
+export declare const CF_APPLICATION_TOKEN = "cf:application";
+export declare const CF_RELATIONAL_TOKEN = "cf:relational";
+export declare const CF_REDIS_TOKEN = "cf:redis";
+export declare const CF_AMQP_TOKEN = "cf:amqp";
+export declare const CF_BLOB_TOKEN = "cf:blob";
+export declare function bindCloudFoundryConnectors(targetContainer?: any, options?: EnableCloudFoundryConnectorsOptions): CloudFoundryEnvironment;

package/dist/bindings.js

@@ -0,0 +1,61 @@
+import { useContainer } from '@di-framework/core/container';
+import { CloudFoundryEnvironment } from './environment.js';
+export const CF_ENVIRONMENT_TOKEN = 'cf:environment';
+export const CF_APPLICATION_TOKEN = 'cf:application';
+export const CF_RELATIONAL_TOKEN = 'cf:relational';
+export const CF_REDIS_TOKEN = 'cf:redis';
+export const CF_AMQP_TOKEN = 'cf:amqp';
+export const CF_BLOB_TOKEN = 'cf:blob';
+// biome-ignore lint/suspicious/noExplicitAny: container interface
+export function bindCloudFoundryConnectors(targetContainer, options = {}) {
+    const container = targetContainer ?? options.container ?? useContainer();
+    const cfEnv = new CloudFoundryEnvironment({
+        env: options.env,
+        localFallback: options.localFallback,
+    });
+    // 1. Register CloudFoundryEnvironment
+    if (typeof container.registerValue === 'function') {
+        container.registerValue(CloudFoundryEnvironment, cfEnv);
+        container.registerValue(CF_ENVIRONMENT_TOKEN, cfEnv);
+    }
+    else if (typeof container.registerInstance === 'function') {
+        container.registerInstance(CloudFoundryEnvironment, cfEnv);
+        container.registerInstance(CF_ENVIRONMENT_TOKEN, cfEnv);
+    }
+    // 2. Register Application Info
+    const appInfo = cfEnv.getApplicationInfo();
+    if (typeof container.registerValue === 'function') {
+        container.registerValue(CF_APPLICATION_TOKEN, appInfo);
+    }
+    // 3. Register Discovered Services
+    const allServices = cfEnv.getServiceInfos();
+    for (const service of allServices) {
+        if (typeof container.registerValue === 'function') {
+            // By specific name
+            container.registerValue(`cf:service:${service.name}`, service);
+            // By label
+            container.registerValue(`cf:service:${service.label}`, service);
+        }
+    }
+    // 4. Register primary service singletons for common types
+    const relational = cfEnv.getRelationalServiceInfo();
+    if (relational && typeof container.registerValue === 'function') {
+        container.registerValue(CF_RELATIONAL_TOKEN, relational);
+        container.registerValue(`cf:${relational.dialect}`, relational);
+    }
+    const redis = cfEnv.getRedisServiceInfo();
+    if (redis && typeof container.registerValue === 'function') {
+        container.registerValue(CF_REDIS_TOKEN, redis);
+    }
+    const amqp = cfEnv.getAmqpServiceInfo();
+    if (amqp && typeof container.registerValue === 'function') {
+        container.registerValue(CF_AMQP_TOKEN, amqp);
+        container.registerValue('cf:rabbitmq', amqp);
+    }
+    const blob = cfEnv.getBlobStorageServiceInfo();
+    if (blob && typeof container.registerValue === 'function') {
+        container.registerValue(CF_BLOB_TOKEN, blob);
+        container.registerValue('cf:s3', blob);
+    }
+    return cfEnv;
+}

package/dist/creators/amqp.d.ts

@@ -0,0 +1,6 @@
+import type { CloudFoundryServiceInfoCreator } from '../spi/creator.js';
+import type { AmqpServiceInfo, RawVcapServiceData } from '../types.js';
+export declare class AmqpServiceInfoCreator implements CloudFoundryServiceInfoCreator<AmqpServiceInfo> {
+    accept(serviceData: RawVcapServiceData): boolean;
+    createServiceInfo(serviceData: RawVcapServiceData): AmqpServiceInfo;
+}

package/dist/creators/amqp.js

@@ -0,0 +1,109 @@
+const AMQP_PATTERNS = ['rabbitmq', 'amqp', 'cloudamqp'];
+function matchesAny(str, patterns) {
+    const lower = str.toLowerCase();
+    return patterns.some((p) => lower.includes(p));
+}
+export class AmqpServiceInfoCreator {
+    accept(serviceData) {
+        const label = serviceData.label || '';
+        const tags = (serviceData.tags || []).map((t) => String(t).toLowerCase());
+        const creds = (serviceData.credentials || {});
+        if (matchesAny(label, AMQP_PATTERNS)) {
+            return true;
+        }
+        if (tags.some((t) => matchesAny(t, AMQP_PATTERNS) || t === 'messaging' || t === 'message-queue')) {
+            return true;
+        }
+        const uriCandidate = String(creds.uri ?? creds.url ?? '');
+        if (uriCandidate.startsWith('amqp://') || uriCandidate.startsWith('amqps://')) {
+            return true;
+        }
+        const urisArray = creds.uris;
+        if (Array.isArray(urisArray) &&
+            urisArray.some((u) => typeof u === 'string' && (u.startsWith('amqp://') || u.startsWith('amqps://')))) {
+            return true;
+        }
+        return false;
+    }
+    createServiceInfo(serviceData) {
+        const creds = (serviceData.credentials || {});
+        const tags = (serviceData.tags || []).map(String);
+        const rawUris = Array.isArray(creds.uris)
+            ? creds.uris.map(String)
+            : typeof creds.uri === 'string'
+                ? [creds.uri]
+                : typeof creds.url === 'string'
+                    ? [creds.url]
+                    : [];
+        let primaryUri = rawUris[0] ?? '';
+        let host = String(creds.hostname ?? creds.host ?? 'localhost');
+        let port = typeof creds.port === 'number' ? creds.port : 5672;
+        if (typeof creds.port === 'string' && creds.port.trim().length > 0) {
+            const p = parseInt(creds.port, 10);
+            if (!Number.isNaN(p))
+                port = p;
+        }
+        let username = (creds.username ?? creds.user) ? String(creds.username ?? creds.user) : undefined;
+        let password = (creds.password ?? creds.pass) ? String(creds.password ?? creds.pass) : undefined;
+        let virtualHost = (creds.vhost ?? creds.virtual_host ?? creds.virtualHost)
+            ? String(creds.vhost ?? creds.virtual_host ?? creds.virtualHost)
+            : undefined;
+        let ssl = typeof creds.ssl === 'boolean'
+            ? creds.ssl
+            : typeof creds.tls === 'boolean'
+                ? creds.tls
+                : undefined;
+        const httpManagementUri = (creds.http_api_uri ?? creds.http_management_uri ?? creds.httpManagementUri)
+            ? String(creds.http_api_uri ?? creds.http_management_uri ?? creds.httpManagementUri)
+            : undefined;
+        if (primaryUri.length > 0) {
+            try {
+                const parsed = new URL(primaryUri);
+                if (parsed.protocol === 'amqps:') {
+                    ssl = true;
+                }
+                else if (parsed.protocol === 'amqp:' && ssl === undefined) {
+                    ssl = false;
+                }
+                if (parsed.hostname)
+                    host = parsed.hostname;
+                if (parsed.port)
+                    port = parseInt(parsed.port, 10);
+                if (parsed.username)
+                    username = decodeURIComponent(parsed.username);
+                if (parsed.password)
+                    password = decodeURIComponent(parsed.password);
+                if (parsed.pathname && parsed.pathname.length > 1) {
+                    virtualHost = decodeURIComponent(parsed.pathname.slice(1));
+                }
+            }
+            catch {
+                // ignore parse error
+            }
+        }
+        if (!primaryUri) {
+            const scheme = ssl ? 'amqps' : 'amqp';
+            const auth = username ? (password ? `${username}:${password}@` : `${username}@`) : '';
+            const vhostPart = virtualHost ? `/${encodeURIComponent(virtualHost)}` : '';
+            primaryUri = `${scheme}://${auth}${host}:${port}${vhostPart}`;
+        }
+        const urisList = rawUris.length > 0 ? rawUris : [primaryUri];
+        return {
+            id: serviceData.name,
+            name: serviceData.name,
+            label: serviceData.label,
+            ...(serviceData.plan ? { plan: serviceData.plan } : {}),
+            tags,
+            credentials: Object.freeze({ ...creds }),
+            host,
+            port,
+            ...(virtualHost !== undefined ? { virtualHost } : {}),
+            ...(username !== undefined ? { username } : {}),
+            ...(password !== undefined ? { password } : {}),
+            uri: primaryUri,
+            uris: urisList,
+            ...(ssl !== undefined ? { ssl } : {}),
+            ...(httpManagementUri !== undefined ? { httpManagementUri } : {}),
+        };
+    }
+}

package/dist/creators/blob-storage.d.ts

@@ -0,0 +1,6 @@
+import type { CloudFoundryServiceInfoCreator } from '../spi/creator.js';
+import type { BlobStorageServiceInfo, RawVcapServiceData } from '../types.js';
+export declare class BlobStorageServiceInfoCreator implements CloudFoundryServiceInfoCreator<BlobStorageServiceInfo> {
+    accept(serviceData: RawVcapServiceData): boolean;
+    createServiceInfo(serviceData: RawVcapServiceData): BlobStorageServiceInfo;
+}

package/dist/creators/blob-storage.js

@@ -0,0 +1,95 @@
+const S3_PATTERNS = ['s3', 'minio', 'objectstore', 'blobstore', 'blob-storage', 'ecs-s3'];
+function matchesAny(str, patterns) {
+    const lower = str.toLowerCase();
+    return patterns.some((p) => lower.includes(p));
+}
+export class BlobStorageServiceInfoCreator {
+    accept(serviceData) {
+        const label = serviceData.label || '';
+        const tags = (serviceData.tags || []).map((t) => String(t).toLowerCase());
+        const creds = (serviceData.credentials || {});
+        if (matchesAny(label, S3_PATTERNS)) {
+            return true;
+        }
+        if (tags.some((t) => matchesAny(t, S3_PATTERNS))) {
+            return true;
+        }
+        if ((creds.bucket || creds.bucket_name || creds.bucketName) &&
+            (creds.access_key_id ||
+                creds.accessKeyId ||
+                creds.access_key ||
+                creds.aws_access_key_id ||
+                creds.endpoint)) {
+            return true;
+        }
+        const uriCandidate = String(creds.uri ?? creds.url ?? '');
+        if (uriCandidate.startsWith('s3://')) {
+            return true;
+        }
+        return false;
+    }
+    createServiceInfo(serviceData) {
+        const creds = (serviceData.credentials || {});
+        const tags = (serviceData.tags || []).map(String);
+        let bucketName = String(creds.bucket_name ?? creds.bucketName ?? creds.bucket ?? creds.name ?? serviceData.name);
+        const endpoint = (creds.endpoint ?? creds.endpoint_url ?? creds.endpointUrl ?? creds.host)
+            ? String(creds.endpoint ?? creds.endpoint_url ?? creds.endpointUrl ?? creds.host)
+            : undefined;
+        const region = (creds.region ?? creds.aws_region ?? creds.s3_region)
+            ? String(creds.region ?? creds.aws_region ?? creds.s3_region)
+            : undefined;
+        let accessKeyId = (creds.access_key_id ?? creds.accessKeyId ?? creds.access_key ?? creds.aws_access_key_id)
+            ? String(creds.access_key_id ?? creds.accessKeyId ?? creds.access_key ?? creds.aws_access_key_id)
+            : undefined;
+        let secretAccessKey = (creds.secret_access_key ??
+            creds.secretAccessKey ??
+            creds.secret_key ??
+            creds.aws_secret_access_key)
+            ? String(creds.secret_access_key ??
+                creds.secretAccessKey ??
+                creds.secret_key ??
+                creds.aws_secret_access_key)
+            : undefined;
+        const pathStyle = typeof creds.path_style === 'boolean'
+            ? creds.path_style
+            : typeof creds.pathStyle === 'boolean'
+                ? creds.pathStyle
+                : undefined;
+        let rawUri = (creds.uri ?? creds.url) ? String(creds.uri ?? creds.url) : undefined;
+        if (rawUri?.startsWith('s3://')) {
+            try {
+                const parsed = new URL(rawUri);
+                if (parsed.hostname)
+                    bucketName = parsed.hostname;
+                if (parsed.username)
+                    accessKeyId = decodeURIComponent(parsed.username);
+                if (parsed.password)
+                    secretAccessKey = decodeURIComponent(parsed.password);
+            }
+            catch {
+                // ignore parse error
+            }
+        }
+        if (!rawUri && endpoint) {
+            rawUri =
+                endpoint.startsWith('http://') || endpoint.startsWith('https://')
+                    ? `${endpoint}/${bucketName}`
+                    : `https://${endpoint}/${bucketName}`;
+        }
+        return {
+            id: serviceData.name,
+            name: serviceData.name,
+            label: serviceData.label,
+            ...(serviceData.plan ? { plan: serviceData.plan } : {}),
+            tags,
+            credentials: Object.freeze({ ...creds }),
+            bucketName,
+            ...(endpoint !== undefined ? { endpoint } : {}),
+            ...(region !== undefined ? { region } : {}),
+            ...(accessKeyId !== undefined ? { accessKeyId } : {}),
+            ...(secretAccessKey !== undefined ? { secretAccessKey } : {}),
+            ...(rawUri !== undefined ? { uri: rawUri } : {}),
+            ...(pathStyle !== undefined ? { pathStyle } : {}),
+        };
+    }
+}

package/dist/creators/redis.d.ts

@@ -0,0 +1,6 @@
+import type { CloudFoundryServiceInfoCreator } from '../spi/creator.js';
+import type { RawVcapServiceData, RedisServiceInfo } from '../types.js';
+export declare class RedisServiceInfoCreator implements CloudFoundryServiceInfoCreator<RedisServiceInfo> {
+    accept(serviceData: RawVcapServiceData): boolean;
+    createServiceInfo(serviceData: RawVcapServiceData): RedisServiceInfo;
+}

package/dist/creators/redis.js

@@ -0,0 +1,95 @@
+const REDIS_PATTERNS = ['redis', 'rediscloud', 'redislabs'];
+function matchesAny(str, patterns) {
+    const lower = str.toLowerCase();
+    return patterns.some((p) => lower.includes(p));
+}
+export class RedisServiceInfoCreator {
+    accept(serviceData) {
+        const label = serviceData.label || '';
+        const tags = (serviceData.tags || []).map((t) => String(t).toLowerCase());
+        const creds = (serviceData.credentials || {});
+        if (matchesAny(label, REDIS_PATTERNS)) {
+            return true;
+        }
+        if (tags.some((t) => matchesAny(t, REDIS_PATTERNS) || t === 'cache')) {
+            return true;
+        }
+        const uriCandidate = String(creds.uri ?? creds.url ?? '');
+        if (uriCandidate.startsWith('redis://') || uriCandidate.startsWith('rediss://')) {
+            return true;
+        }
+        return false;
+    }
+    createServiceInfo(serviceData) {
+        const creds = (serviceData.credentials || {});
+        const tags = (serviceData.tags || []).map(String);
+        let rawUri = String(creds.uri ?? creds.url ?? '');
+        let host = String(creds.host ?? creds.hostname ?? 'localhost');
+        let port = typeof creds.port === 'number' ? creds.port : 6379;
+        if (typeof creds.port === 'string' && creds.port.trim().length > 0) {
+            const p = parseInt(creds.port, 10);
+            if (!Number.isNaN(p))
+                port = p;
+        }
+        let password = creds.password ? String(creds.password) : undefined;
+        let database;
+        if (typeof creds.database === 'number') {
+            database = creds.database;
+        }
+        else if (typeof creds.db === 'number') {
+            database = creds.db;
+        }
+        let tls = typeof creds.tls === 'boolean'
+            ? creds.tls
+            : typeof creds.ssl === 'boolean'
+                ? creds.ssl
+                : undefined;
+        const cluster = typeof creds.cluster === 'boolean' ? creds.cluster : undefined;
+        if (rawUri.length > 0) {
+            try {
+                const parsed = new URL(rawUri);
+                if (parsed.protocol === 'rediss:') {
+                    tls = true;
+                }
+                else if (parsed.protocol === 'redis:' && tls === undefined) {
+                    tls = false;
+                }
+                if (parsed.hostname)
+                    host = parsed.hostname;
+                if (parsed.port)
+                    port = parseInt(parsed.port, 10);
+                if (parsed.password)
+                    password = decodeURIComponent(parsed.password);
+                if (parsed.pathname && parsed.pathname.length > 1) {
+                    const dbIndex = parseInt(parsed.pathname.slice(1), 10);
+                    if (!Number.isNaN(dbIndex))
+                        database = dbIndex;
+                }
+            }
+            catch {
+                // ignore url parse error
+            }
+        }
+        if (!rawUri) {
+            const scheme = tls ? 'rediss' : 'redis';
+            const auth = password ? `:${encodeURIComponent(password)}@` : '';
+            const dbPath = database !== undefined ? `/${database}` : '';
+            rawUri = `${scheme}://${auth}${host}:${port}${dbPath}`;
+        }
+        return {
+            id: serviceData.name,
+            name: serviceData.name,
+            label: serviceData.label,
+            ...(serviceData.plan ? { plan: serviceData.plan } : {}),
+            tags,
+            credentials: Object.freeze({ ...creds }),
+            host,
+            port,
+            ...(password !== undefined ? { password } : {}),
+            ...(database !== undefined ? { database } : {}),
+            uri: rawUri,
+            ...(tls !== undefined ? { tls } : {}),
+            ...(cluster !== undefined ? { cluster } : {}),
+        };
+    }
+}

package/dist/creators/relational.d.ts

@@ -0,0 +1,6 @@
+import type { CloudFoundryServiceInfoCreator } from '../spi/creator.js';
+import type { RawVcapServiceData, RelationalServiceInfo } from '../types.js';
+export declare class RelationalServiceInfoCreator implements CloudFoundryServiceInfoCreator<RelationalServiceInfo> {
+    accept(serviceData: RawVcapServiceData): boolean;
+    createServiceInfo(serviceData: RawVcapServiceData): RelationalServiceInfo;
+}