@di-framework/cloudfoundry 5.2.3

package/dist/environment.js

@@ -0,0 +1,326 @@
+import { parseVcapApplication } from './application-info.js';
+import { CloudFoundryDetector } from './detector.js';
+import { getDefaultRegistry, parseVcapServices, } from './spi/registry.js';
+export class CloudFoundryEnvironment {
+    env;
+    registry;
+    localFallbackOptions;
+    appInfo;
+    services;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.registry = options.registry ?? getDefaultRegistry();
+        if (options.localFallback === false) {
+            this.localFallbackOptions = null;
+        }
+        else if (typeof options.localFallback === 'object') {
+            this.localFallbackOptions = options.localFallback;
+        }
+        else {
+            // Default enabled
+            this.localFallbackOptions = {};
+        }
+    }
+    /**
+     * Returns true if running within a Cloud Foundry runtime.
+     */
+    isCloudFoundry() {
+        return CloudFoundryDetector.isCloudFoundry(this.env);
+    }
+    /**
+     * Returns parsed CloudFoundryApplicationInfo or null if not running in CF.
+     */
+    getApplicationInfo() {
+        if (this.appInfo === undefined) {
+            this.appInfo = parseVcapApplication(this.env);
+        }
+        return this.appInfo;
+    }
+    /**
+     * Retrieves all discovered Cloud Foundry services, applying optional filtering.
+     */
+    getServiceInfos(filter) {
+        this.ensureServicesLoaded();
+        const all = (this.services ?? []);
+        if (!filter) {
+            return all;
+        }
+        if (typeof filter === 'string') {
+            return all.filter((s) => s.name === filter || s.label === filter || s.tags.includes(filter));
+        }
+        if (filter instanceof RegExp) {
+            return all.filter((s) => filter.test(s.name) || filter.test(s.label));
+        }
+        return all.filter((service) => {
+            if (filter.name) {
+                if (typeof filter.name === 'string' && service.name !== filter.name)
+                    return false;
+                if (filter.name instanceof RegExp && !filter.name.test(service.name))
+                    return false;
+            }
+            if (filter.label) {
+                if (typeof filter.label === 'string' && service.label !== filter.label)
+                    return false;
+                if (filter.label instanceof RegExp && !filter.label.test(service.label))
+                    return false;
+            }
+            if (filter.tag) {
+                if (typeof filter.tag === 'string' && !service.tags.includes(filter.tag))
+                    return false;
+                if (filter.tag instanceof RegExp &&
+                    !service.tags.some((t) => filter.tag.test(t)))
+                    return false;
+            }
+            if (filter.dialect) {
+                if (!('dialect' in service) ||
+                    service.dialect !== filter.dialect) {
+                    return false;
+                }
+            }
+            if (filter.predicate && !filter.predicate(service)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Retrieves a single service by name, filter, or returns the first matching service.
+     */
+    getServiceInfo(serviceNameOrFilter) {
+        const list = this.getServiceInfos(serviceNameOrFilter);
+        return list[0] ?? null;
+    }
+    /**
+     * Retrieves relational database service info (PostgreSQL, MySQL, MariaDB, SQLite).
+     */
+    getRelationalServiceInfo(filter) {
+        if (typeof filter === 'string' || filter instanceof RegExp) {
+            const found = this.getServiceInfo(filter);
+            if (found && 'dialect' in found)
+                return found;
+        }
+        else if (filter) {
+            const found = this.getServiceInfo(filter);
+            if (found && 'dialect' in found)
+                return found;
+        }
+        // Find any relational service
+        const all = this.getServiceInfos();
+        return all.find((s) => 'dialect' in s) ?? null;
+    }
+    /**
+     * Retrieves Redis service info.
+     */
+    getRedisServiceInfo(filter) {
+        if (typeof filter === 'string' || filter instanceof RegExp) {
+            const found = this.getServiceInfo(filter);
+            if (found && isRedisInfo(found))
+                return found;
+        }
+        else if (filter) {
+            const found = this.getServiceInfo(filter);
+            if (found && isRedisInfo(found))
+                return found;
+        }
+        const all = this.getServiceInfos();
+        return all.find((s) => isRedisInfo(s)) ?? null;
+    }
+    /**
+     * Retrieves AMQP / RabbitMQ service info.
+     */
+    getAmqpServiceInfo(filter) {
+        if (typeof filter === 'string' || filter instanceof RegExp) {
+            const found = this.getServiceInfo(filter);
+            if (found && isAmqpInfo(found))
+                return found;
+        }
+        else if (filter) {
+            const found = this.getServiceInfo(filter);
+            if (found && isAmqpInfo(found))
+                return found;
+        }
+        const all = this.getServiceInfos();
+        return all.find((s) => isAmqpInfo(s)) ?? null;
+    }
+    /**
+     * Retrieves Blob Storage / S3 service info.
+     */
+    getBlobStorageServiceInfo(filter) {
+        if (typeof filter === 'string' || filter instanceof RegExp) {
+            const found = this.getServiceInfo(filter);
+            if (found && isBlobStorageInfo(found))
+                return found;
+        }
+        else if (filter) {
+            const found = this.getServiceInfo(filter);
+            if (found && isBlobStorageInfo(found))
+                return found;
+        }
+        const all = this.getServiceInfos();
+        return all.find((s) => isBlobStorageInfo(s)) ?? null;
+    }
+    /**
+     * Retrieves User-Provided service info.
+     */
+    getUserProvidedServiceInfo(filter) {
+        if (typeof filter === 'string' || filter instanceof RegExp) {
+            return this.getServiceInfo(filter);
+        }
+        const all = this.getServiceInfos({
+            label: 'user-provided',
+            ...(filter || {}),
+        });
+        return all[0] ?? null;
+    }
+    /**
+     * Retrieves raw credentials map for a service.
+     */
+    getServiceCredentials(serviceName) {
+        const service = this.getServiceInfo(serviceName);
+        return service ? service.credentials : null;
+    }
+    ensureServicesLoaded() {
+        if (this.services !== undefined)
+            return;
+        let discovered = parseVcapServices(this.env, this.registry);
+        if (discovered.length === 0 && this.localFallbackOptions) {
+            discovered = this.buildLocalFallbackServices(this.localFallbackOptions);
+        }
+        this.services = discovered;
+    }
+    buildLocalFallbackServices(options) {
+        const list = [];
+        // 1. Explicit local fallback services
+        if (options.services) {
+            for (const [name, partial] of Object.entries(options.services)) {
+                list.push({
+                    id: partial.id ?? name,
+                    name: partial.name ?? name,
+                    label: partial.label ?? 'local-fallback',
+                    tags: partial.tags ?? ['local'],
+                    credentials: Object.freeze({ ...(partial.credentials || {}) }),
+                    ...partial,
+                });
+            }
+        }
+        // 2. Relational fallback from environment variables
+        const relationalKeys = options.relationalUriEnv ?? [
+            'DATABASE_URL',
+            'POSTGRES_URL',
+            'POSTGRESQL_URL',
+            'MYSQL_URL',
+            'MARIADB_URL',
+            'SQLITE_URL',
+        ];
+        for (const key of relationalKeys) {
+            const uriVal = this.env[key];
+            if (uriVal && uriVal.trim().length > 0) {
+                const rawEntry = {
+                    name: 'local-db',
+                    label: 'relational',
+                    tags: ['local', 'relational'],
+                    credentials: { uri: uriVal.trim() },
+                };
+                list.push(this.registry.createServiceInfo(rawEntry));
+                break;
+            }
+        }
+        // 3. Redis fallback
+        const redisKeys = options.redisUriEnv ?? ['REDIS_URL', 'REDIS_TLS_URL', 'REDISCLOUD_URL'];
+        for (const key of redisKeys) {
+            const uriVal = this.env[key];
+            if (uriVal && uriVal.trim().length > 0) {
+                const rawEntry = {
+                    name: 'local-redis',
+                    label: 'redis',
+                    tags: ['local', 'redis', 'cache'],
+                    credentials: { uri: uriVal.trim() },
+                };
+                list.push(this.registry.createServiceInfo(rawEntry));
+                break;
+            }
+        }
+        // 4. AMQP fallback
+        const amqpKeys = options.amqpUriEnv ?? [
+            'AMQP_URL',
+            'RABBITMQ_URL',
+            'CLOUDAMQP_URL',
+            'RABBITMQ_BIGWIG_URL',
+        ];
+        for (const key of amqpKeys) {
+            const uriVal = this.env[key];
+            if (uriVal && uriVal.trim().length > 0) {
+                const rawEntry = {
+                    name: 'local-amqp',
+                    label: 'rabbitmq',
+                    tags: ['local', 'amqp', 'rabbitmq'],
+                    credentials: { uri: uriVal.trim() },
+                };
+                list.push(this.registry.createServiceInfo(rawEntry));
+                break;
+            }
+        }
+        // 5. Blob storage fallback
+        const blobBucket = options.blobStorageEnv?.bucket ??
+            this.env.S3_BUCKET ??
+            this.env.AWS_S3_BUCKET ??
+            this.env.BLOB_STORAGE_BUCKET;
+        if (blobBucket) {
+            const rawEntry = {
+                name: 'local-blob-storage',
+                label: 's3',
+                tags: ['local', 's3', 'blob'],
+                credentials: {
+                    bucket: blobBucket,
+                    endpoint: options.blobStorageEnv?.endpoint ??
+                        this.env.S3_ENDPOINT ??
+                        this.env.AWS_ENDPOINT_URL_S3 ??
+                        this.env.AWS_ENDPOINT_URL,
+                    region: options.blobStorageEnv?.region ??
+                        this.env.AWS_REGION ??
+                        this.env.AWS_DEFAULT_REGION ??
+                        'us-east-1',
+                    accessKeyId: options.blobStorageEnv?.accessKeyId ??
+                        this.env.AWS_ACCESS_KEY_ID ??
+                        this.env.S3_ACCESS_KEY,
+                    secretAccessKey: options.blobStorageEnv?.secretAccessKey ??
+                        this.env.AWS_SECRET_ACCESS_KEY ??
+                        this.env.S3_SECRET_KEY,
+                },
+            };
+            list.push(this.registry.createServiceInfo(rawEntry));
+        }
+        return list;
+    }
+}
+function isRedisInfo(s) {
+    return ('host' in s &&
+        'port' in s &&
+        (s.label.toLowerCase().includes('redis') ||
+            s.tags.includes('redis') ||
+            s.tags.includes('cache')));
+}
+function isAmqpInfo(s) {
+    return ('uris' in s ||
+        s.label.toLowerCase().includes('rabbitmq') ||
+        s.label.toLowerCase().includes('amqp') ||
+        s.tags.includes('rabbitmq') ||
+        s.tags.includes('amqp'));
+}
+function isBlobStorageInfo(s) {
+    return ('bucketName' in s ||
+        s.label.toLowerCase().includes('s3') ||
+        s.tags.includes('s3') ||
+        s.tags.includes('blob') ||
+        s.tags.includes('blobstore'));
+}
+let defaultEnvironment = null;
+export function getDefaultEnvironment() {
+    if (!defaultEnvironment) {
+        defaultEnvironment = new CloudFoundryEnvironment();
+    }
+    return defaultEnvironment;
+}
+export function resetDefaultEnvironment() {
+    defaultEnvironment = null;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { parseVcapApplication } from './application-info.js';
+export { bindCloudFoundryConnectors, CF_AMQP_TOKEN, CF_APPLICATION_TOKEN, CF_BLOB_TOKEN, CF_ENVIRONMENT_TOKEN, CF_REDIS_TOKEN, CF_RELATIONAL_TOKEN, } from './bindings.js';
+export { AmqpServiceInfoCreator } from './creators/amqp.js';
+export { BlobStorageServiceInfoCreator } from './creators/blob-storage.js';
+export { RedisServiceInfoCreator } from './creators/redis.js';
+export { RelationalServiceInfoCreator } from './creators/relational.js';
+export { UserProvidedServiceInfoCreator } from './creators/user-provided.js';
+export { CloudFoundryService, EnableCloudFoundryConnectors, VcapApplication, } from './decorators.js';
+export { CloudFoundryDetector, isCloudFoundry, } from './detector.js';
+export { CloudFoundryEnvironment, type CloudFoundryEnvironmentOptions, getDefaultEnvironment, resetDefaultEnvironment, } from './environment.js';
+export type { CloudFoundryServiceInfoCreator } from './spi/creator.js';
+export { getDefaultRegistry, parseVcapServices, ServiceInfoCreatorRegistry, } from './spi/registry.js';
+export type { AmqpServiceInfo, BlobStorageServiceInfo, CloudFoundryApplicationInfo, CloudFoundryServiceInfo, CloudFoundryServiceOptions, EnableCloudFoundryConnectorsOptions, LocalFallbackOptions, RawVcapServiceData, RedisServiceInfo, RelationalDialect, RelationalServiceInfo, ServiceFilter, ServicePredicate, UserProvidedServiceInfo, } from './types.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+export { parseVcapApplication } from './application-info.js';
+export { bindCloudFoundryConnectors, CF_AMQP_TOKEN, CF_APPLICATION_TOKEN, CF_BLOB_TOKEN, CF_ENVIRONMENT_TOKEN, CF_REDIS_TOKEN, CF_RELATIONAL_TOKEN, } from './bindings.js';
+export { AmqpServiceInfoCreator } from './creators/amqp.js';
+export { BlobStorageServiceInfoCreator } from './creators/blob-storage.js';
+export { RedisServiceInfoCreator } from './creators/redis.js';
+export { RelationalServiceInfoCreator } from './creators/relational.js';
+export { UserProvidedServiceInfoCreator } from './creators/user-provided.js';
+export { CloudFoundryService, EnableCloudFoundryConnectors, VcapApplication, } from './decorators.js';
+export { CloudFoundryDetector, isCloudFoundry, } from './detector.js';
+export { CloudFoundryEnvironment, getDefaultEnvironment, resetDefaultEnvironment, } from './environment.js';
+export { getDefaultRegistry, parseVcapServices, ServiceInfoCreatorRegistry, } from './spi/registry.js';

package/dist/spi/creator.d.ts

@@ -0,0 +1,15 @@
+import type { CloudFoundryServiceInfo, RawVcapServiceData } from '../types.js';
+/**
+ * Service Provider Interface (SPI) for converting raw VCAP_SERVICES entry data
+ * into a typed CloudFoundryServiceInfo model.
+ */
+export interface CloudFoundryServiceInfoCreator<T extends CloudFoundryServiceInfo = CloudFoundryServiceInfo> {
+    /**
+     * Evaluates if this creator accepts and can parse the given raw service entry.
+     */
+    accept(serviceData: RawVcapServiceData): boolean;
+    /**
+     * Constructs the strongly typed ServiceInfo model from the service data.
+     */
+    createServiceInfo(serviceData: RawVcapServiceData): T;
+}

package/dist/spi/creator.js

@@ -0,0 +1 @@
+export {};

package/dist/spi/registry.d.ts

@@ -0,0 +1,28 @@
+import type { CloudFoundryServiceInfo, RawVcapServiceData } from '../types.js';
+import type { CloudFoundryServiceInfoCreator } from './creator.js';
+export declare class ServiceInfoCreatorRegistry {
+    private creators;
+    constructor(registerDefaults?: boolean);
+    private registerDefaultCreators;
+    /**
+     * Registers a custom service info creator.
+     * By default, custom creators are inserted with higher priority than built-ins.
+     */
+    registerCreator(creator: CloudFoundryServiceInfoCreator, options?: {
+        priority?: 'high' | 'low';
+    }): this;
+    /**
+     * Finds the first matching creator for the given raw service entry.
+     */
+    findCreator(serviceData: RawVcapServiceData): CloudFoundryServiceInfoCreator | undefined;
+    /**
+     * Converts a single raw service data object into a typed ServiceInfo model.
+     */
+    createServiceInfo(serviceData: RawVcapServiceData): CloudFoundryServiceInfo;
+    /**
+     * Parses raw VCAP_SERVICES payload and produces typed service models.
+     */
+    parseVcapServices(input?: string | Record<string, unknown> | readonly RawVcapServiceData[]): readonly CloudFoundryServiceInfo[];
+}
+export declare function getDefaultRegistry(): ServiceInfoCreatorRegistry;
+export declare function parseVcapServices(input?: string | Record<string, unknown> | readonly RawVcapServiceData[], registry?: ServiceInfoCreatorRegistry): readonly CloudFoundryServiceInfo[];

package/dist/spi/registry.js

@@ -0,0 +1,161 @@
+import { AmqpServiceInfoCreator } from '../creators/amqp.js';
+import { BlobStorageServiceInfoCreator } from '../creators/blob-storage.js';
+import { RedisServiceInfoCreator } from '../creators/redis.js';
+import { RelationalServiceInfoCreator } from '../creators/relational.js';
+import { UserProvidedServiceInfoCreator } from '../creators/user-provided.js';
+import { CloudFoundryDetector } from '../detector.js';
+export class ServiceInfoCreatorRegistry {
+    creators = [];
+    constructor(registerDefaults = true) {
+        if (registerDefaults) {
+            this.registerDefaultCreators();
+        }
+    }
+    registerDefaultCreators() {
+        this.creators.push(new RelationalServiceInfoCreator());
+        this.creators.push(new RedisServiceInfoCreator());
+        this.creators.push(new AmqpServiceInfoCreator());
+        this.creators.push(new BlobStorageServiceInfoCreator());
+        this.creators.push(new UserProvidedServiceInfoCreator());
+    }
+    /**
+     * Registers a custom service info creator.
+     * By default, custom creators are inserted with higher priority than built-ins.
+     */
+    registerCreator(creator, options = { priority: 'high' }) {
+        if (options.priority === 'low') {
+            this.creators.push(creator);
+        }
+        else {
+            this.creators.unshift(creator);
+        }
+        return this;
+    }
+    /**
+     * Finds the first matching creator for the given raw service entry.
+     */
+    findCreator(serviceData) {
+        return this.creators.find((c) => {
+            try {
+                return c.accept(serviceData);
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    /**
+     * Converts a single raw service data object into a typed ServiceInfo model.
+     */
+    createServiceInfo(serviceData) {
+        const creator = this.findCreator(serviceData);
+        if (creator) {
+            return creator.createServiceInfo(serviceData);
+        }
+        // Default fallback if no creator accepts
+        return {
+            id: serviceData.name,
+            name: serviceData.name,
+            label: serviceData.label || 'unknown',
+            ...(serviceData.plan ? { plan: serviceData.plan } : {}),
+            tags: (serviceData.tags || []).map(String),
+            credentials: Object.freeze({ ...(serviceData.credentials || {}) }),
+        };
+    }
+    /**
+     * Parses raw VCAP_SERVICES payload and produces typed service models.
+     */
+    parseVcapServices(input) {
+        const rawServices = extractRawServices(input);
+        return rawServices.map((entry) => this.createServiceInfo(entry));
+    }
+}
+function extractRawServices(input) {
+    if (input === null) {
+        return [];
+    }
+    let parsed = null;
+    if (input === undefined) {
+        const rawJson = CloudFoundryDetector.getServicesJson();
+        if (!rawJson)
+            return [];
+        try {
+            parsed = JSON.parse(rawJson);
+        }
+        catch {
+            return [];
+        }
+    }
+    else if (typeof input === 'string') {
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            return [];
+        }
+    }
+    else if (Array.isArray(input)) {
+        return [...input];
+    }
+    else if (typeof input === 'object') {
+        if ('VCAP_SERVICES' in input) {
+            const vcapVal = input.VCAP_SERVICES;
+            if (typeof vcapVal === 'string' && vcapVal.trim().length > 0) {
+                try {
+                    parsed = JSON.parse(vcapVal);
+                }
+                catch {
+                    return [];
+                }
+            }
+            else if (typeof vcapVal === 'object' && vcapVal !== null) {
+                parsed = vcapVal;
+            }
+            else {
+                return [];
+            }
+        }
+        else {
+            parsed = input;
+        }
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return [];
+    }
+    const results = [];
+    // VCAP_SERVICES format is { "label-name": [ { name, label, credentials, ... } ] }
+    for (const [groupKey, serviceList] of Object.entries(parsed)) {
+        if (Array.isArray(serviceList)) {
+            for (const item of serviceList) {
+                if (typeof item === 'object' && item !== null) {
+                    const rawItem = item;
+                    const name = String(rawItem.name ?? groupKey);
+                    const label = String(rawItem.label ?? groupKey);
+                    results.push({
+                        name,
+                        label,
+                        tags: Array.isArray(rawItem.tags) ? rawItem.tags.map(String) : [],
+                        plan: typeof rawItem.plan === 'string' ? rawItem.plan : undefined,
+                        credentials: (rawItem.credentials || {}),
+                        volume_mounts: Array.isArray(rawItem.volume_mounts) ? rawItem.volume_mounts : undefined,
+                        syslog_drain_url: typeof rawItem.syslog_drain_url === 'string' ? rawItem.syslog_drain_url : undefined,
+                        provider: typeof rawItem.provider === 'string' ? rawItem.provider : undefined,
+                        binding_name: typeof rawItem.binding_name === 'string' ? rawItem.binding_name : undefined,
+                        instance_name: typeof rawItem.instance_name === 'string' ? rawItem.instance_name : undefined,
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+let defaultRegistry = null;
+export function getDefaultRegistry() {
+    if (!defaultRegistry) {
+        defaultRegistry = new ServiceInfoCreatorRegistry();
+    }
+    return defaultRegistry;
+}
+export function parseVcapServices(input, registry = getDefaultRegistry()) {
+    return registry.parseVcapServices(input);
+}