@vibesdotdev/config 0.0.1

package/src/services/loader/loader.descriptor.ts

@@ -0,0 +1,96 @@
+/**
+ * Config Loader Descriptor
+ *
+ * Defines the config/loader kind for runtime-scoped configuration loading.
+ * Each implementation is single-purpose: local-only, cloud-only, or hybrid via runtime composition.
+ *
+ * This replaces the monolithic UnifiedConfigLoader with separate runtime-scoped implementations.
+ */
+
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+import * as z from 'zod/v4';
+import type { ConfigManifest } from '../../manifest/types.ts';
+
+/**
+ * Load result schema - returned by all loader implementations
+ */
+export const LoadResultSchema = z.object({
+	data: z.unknown().nullable(),
+	source: z.enum(['local', 'cloud', 'cache', 'default']),
+	inSync: z.boolean(),
+	lastSyncedAt: z.date().nullable(),
+	syncError: z.string().optional()
+});
+
+export type LoadResult<T = unknown> = {
+	data: T | null;
+	source: 'local' | 'cloud' | 'cache' | 'default';
+	inSync: boolean;
+	lastSyncedAt: Date | null;
+	syncError?: string;
+};
+
+/**
+ * Save result schema
+ */
+export const SaveResultSchema = z.object({
+	success: z.boolean(),
+	direction: z.enum(['push', 'pull', 'none']),
+	changesApplied: z.number(),
+	error: z.string().optional()
+});
+
+export type SaveResult = {
+	success: boolean;
+	direction: 'push' | 'pull' | 'none';
+	changesApplied: number;
+	error?: string;
+};
+
+/**
+ * Config loader interface - implemented by all scoped implementations
+ */
+export interface ConfigLoaderInterface {
+	/** Load configuration for a manifest */
+	load<T>(manifest: ConfigManifest): Promise<LoadResult<T>>;
+
+	/** Save configuration for a manifest */
+	save<T>(manifest: ConfigManifest, data: T): Promise<SaveResult>;
+
+	/** Sync configuration between sources (if applicable) */
+	sync?(manifest: ConfigManifest, direction?: 'push' | 'pull' | 'auto'): Promise<SaveResult>;
+}
+
+/**
+ * Config loader descriptor
+ *
+ * The config/loader kind provides scoped implementations for loading and saving configuration.
+ * Implementations are selected by the runtime based on scope constraints:
+ * - consumer + { storage: 'local' } → LocalConfigLoader (localDB only)
+ * - cloud + { storage: 'cloud' } → CloudConfigLoader (cloud API only)
+ * - consumer + { storage: 'local-first' } → LocalFirstLoader (runtime-composed hybrid)
+ *
+ * @example
+ * ```typescript
+ * const loader = await runtime.query('config/loader').resolve();
+ * const result = await loader.load(manifest);
+ * ```
+ */
+export const configLoaderDescriptor = createRuntimeAsset({
+	kind: 'config/loader',
+	id: 'config.loader.base',
+	name: 'Config Loader',
+	description: 'Runtime-scoped configuration loading and persistence',
+
+	// Schemas for validation
+	schemas: {
+		input: z.object({ manifest: z.custom<ConfigManifest>() }),
+		output: LoadResultSchema
+	},
+
+	// No default implementation - runtime selects by scope
+	// Implementations register separately with their scope constraints
+	enabled: true
+});
+
+export default configLoaderDescriptor;

package/src/services/loader/loader.impl.cloud.ts

@@ -0,0 +1,214 @@
+/**
+ * Config Loader - Cloud Implementation
+ *
+ * Cloud-only configuration loading using cloud settings API.
+ * Single-purpose: handles cloud persistence only, no local branching.
+ *
+ * Scope: { hardware: ['cloud'], qualifiers: { storage: 'cloud' }}
+ *
+ * This replaces the branching logic in UnifiedConfigLoader with a pure
+ * runtime-selected implementation.
+ */
+
+import { createRuntimeImplementation, getVibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigManifest } from '../../manifest/types.ts';
+import type { VibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigLoaderInterface, LoadResult, SaveResult } from './loader.descriptor.ts';
+
+/**
+ * Cloud settings store interface - resolved from runtime
+ */
+interface CloudSettingsStore {
+	get<T>(namespace: string): Promise<T | null>;
+	set<T>(namespace: string, data: T): Promise<void>;
+	delete(namespace: string): Promise<void>;
+}
+
+/**
+ * Cloud Config Loader
+ *
+ * Single-purpose implementation for cloud-only configuration.
+ * Resolves cloud storage through the runtime - no internal adapter Maps.
+ * No syncDirection. No local storage logic.
+ */
+export class CloudConfigLoader implements ConfigLoaderInterface {
+	private runtime: VibesRuntime;
+	private store: CloudSettingsStore | null = null;
+
+	constructor() {
+		this.runtime = getVibesRuntime();
+	}
+
+	/**
+	 * Get cloud settings store from runtime
+	 * Resolved dynamically to respect runtime scope
+	 */
+	private async getStore(): Promise<CloudSettingsStore | null> {
+		if (this.store) return this.store;
+
+		// Query runtime for cloud settings store
+		// This is resolved based on current runtime scope
+		try {
+			const storeImpl = await this.runtime
+				.query('storage/adapter')
+				.matching({
+					qualifiers: { type: 'cloud', purpose: 'settings' }
+				})
+				.resolve();
+
+			if (storeImpl && typeof storeImpl === 'object' && 'documentStore' in storeImpl) {
+				this.store = this.wrapAdapter(storeImpl);
+				return this.store;
+			}
+		} catch {
+			// No cloud adapter available
+		}
+
+		return null;
+	}
+
+	/**
+	 * Wrap a storage adapter to CloudSettingsStore interface
+	 */
+	private wrapAdapter(adapter: unknown): CloudSettingsStore {
+		const docStore = adapter as {
+			load<T>(): Promise<T | null>;
+			save<T>(data: T): Promise<void>;
+			delete(): Promise<void>;
+		};
+
+		return {
+			async get<T>(namespace: string): Promise<T | null> {
+				// The adapter already has namespace baked in via documentStore()
+				// This is a simplified wrapper - real implementation would use proper namespacing
+				return docStore.load<T>();
+			},
+			async set<T>(namespace: string, data: T): Promise<void> {
+				return docStore.save(data);
+			},
+			async delete(namespace: string): Promise<void> {
+				return docStore.delete();
+			}
+		};
+	}
+
+	/**
+	 * Load configuration from cloud storage only
+	 */
+	async load<T>(manifest: ConfigManifest): Promise<LoadResult<T>> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const store = await this.getStore();
+			if (!store) {
+				return {
+					data: null,
+					source: 'default',
+					inSync: true,
+					lastSyncedAt: null
+				};
+			}
+
+			const data = await store.get<T>(namespace);
+
+			return {
+				data,
+				source: data !== null ? 'cloud' : 'default',
+				inSync: true,
+				lastSyncedAt: null
+			};
+		} catch (error) {
+			return {
+				data: null,
+				source: 'default',
+				inSync: false,
+				lastSyncedAt: null,
+				syncError: error instanceof Error ? error.message : 'Cloud load failed'
+			};
+		}
+	}
+
+	/**
+	 * Save configuration to cloud storage only
+	 */
+	async save<T>(manifest: ConfigManifest, data: T): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const store = await this.getStore();
+			if (!store) {
+				return {
+					success: false,
+					direction: 'none',
+					changesApplied: 0,
+					error: 'No cloud store available'
+				};
+			}
+
+			await store.set(namespace, data);
+
+			return {
+				success: true,
+				direction: 'push',
+				changesApplied: 1
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Cloud save failed'
+			};
+		}
+	}
+
+	/**
+	 * Delete configuration from cloud storage
+	 */
+	async delete(manifest: ConfigManifest): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const store = await this.getStore();
+			if (!store) {
+				return {
+					success: false,
+					direction: 'none',
+					changesApplied: 0,
+					error: 'No cloud store available'
+				};
+			}
+
+			await store.delete(namespace);
+
+			return {
+				success: true,
+				direction: 'none',
+				changesApplied: 1
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Cloud delete failed'
+			};
+		}
+	}
+}
+
+/**
+ * Runtime implementation registration
+ *
+ * Scope: cloud hardware with cloud storage qualifier.
+ * No syncDirection. No local storage. Single-purpose.
+ */
+export default createRuntimeImplementation({
+	kind: 'config/loader',
+	id: 'config.loader.cloud',
+	implementation: CloudConfigLoader,
+	constraint: {
+		hardware: ['cloud'],
+		qualifiers: { storage: 'cloud' }
+	}
+});