sandly 0.5.3 → 1.0.1

package/dist/index.js

@@ -1,3 +1,158 @@
+//#region src/layer.ts
+/**
+* The type ID for the Layer interface.
+*/
+const LayerTypeId = Symbol.for("sandly/Layer");
+/**
+* Creates a new dependency layer that encapsulates a set of dependency registrations.
+* Layers are the primary building blocks for organizing and composing dependency injection setups.
+*
+* @template TRequires - The union of dependency tags this layer requires from other layers or external setup
+* @template TProvides - The union of dependency tags this layer registers/provides
+*
+* @param register - Function that performs the dependency registrations. Receives a container.
+* @returns The layer instance.
+*
+* @example Simple layer
+* ```typescript
+* import { layer, Tag } from 'sandly';
+*
+* class DatabaseService extends Tag.Service('DatabaseService') {
+*   constructor(private url: string = 'sqlite://memory') {}
+*   query() { return 'data'; }
+* }
+*
+* // Layer that provides DatabaseService, requires nothing
+* const databaseLayer = layer<never, typeof DatabaseService>((container) =>
+*   container.register(DatabaseService, () => new DatabaseService())
+* );
+*
+* // Usage
+* const dbLayerInstance = databaseLayer;
+* ```
+*
+* @example Complex application layer structure
+* ```typescript
+* // Configuration layer
+* const configLayer = layer<never, typeof ConfigTag>((container) =>
+*   container.register(ConfigTag, () => loadConfig())
+* );
+*
+* // Infrastructure layer (requires config)
+* const infraLayer = layer<typeof ConfigTag, typeof DatabaseService | typeof CacheService>(
+*   (container) =>
+*     container
+*       .register(DatabaseService, async (ctx) => new DatabaseService(await ctx.resolve(ConfigTag)))
+*       .register(CacheService, async (ctx) => new CacheService(await ctx.resolve(ConfigTag)))
+* );
+*
+* // Service layer (requires infrastructure)
+* const serviceLayer = layer<typeof DatabaseService | typeof CacheService, typeof UserService>(
+*   (container) =>
+*     container.register(UserService, async (ctx) =>
+*       new UserService(await ctx.resolve(DatabaseService), await ctx.resolve(CacheService))
+*     )
+* );
+*
+* // Compose the complete application
+* const appLayer = serviceLayer.provide(infraLayer).provide(configLayer);
+* ```
+*/
+function layer(register) {
+	const layerImpl = {
+		register: (container) => register(container),
+		provide(dependency$1) {
+			return createProvidedLayer(dependency$1, layerImpl);
+		},
+		provideMerge(dependency$1) {
+			return createComposedLayer(dependency$1, layerImpl);
+		},
+		merge(other) {
+			return createMergedLayer(layerImpl, other);
+		}
+	};
+	return layerImpl;
+}
+/**
+* Internal function to create a provided layer from two layers.
+* This implements the `.provide()` method logic - only exposes target layer's provisions.
+*
+* @internal
+*/
+function createProvidedLayer(dependency$1, target) {
+	return createComposedLayer(dependency$1, target);
+}
+/**
+* Internal function to create a composed layer from two layers.
+* This implements the `.provideMerge()` method logic - exposes both layers' provisions.
+*
+* @internal
+*/
+function createComposedLayer(dependency$1, target) {
+	return layer((container) => {
+		const containerWithDependency = dependency$1.register(
+			container
+			// The type
+			// IContainer<TRequires1 | TProvides1 | Exclude<TRequires2, TProvides1> | TContainer>
+			// can be simplified to
+			// IContainer<TRequires1 | TRequires2 | TProvides1 | TContainer>
+);
+		return target.register(containerWithDependency);
+	});
+}
+/**
+* Internal function to create a merged layer from two layers.
+* This implements the `.merge()` method logic.
+*
+* @internal
+*/
+function createMergedLayer(layer1, layer2) {
+	return layer((container) => {
+		const container1 = layer1.register(container);
+		const container2 = layer2.register(container1);
+		return container2;
+	});
+}
+/**
+* Utility object containing helper functions for working with layers.
+*/
+const Layer = {
+	empty() {
+		return layer((container) => container);
+	},
+	mergeAll(...layers) {
+		return layers.reduce((acc, layer$1) => acc.merge(layer$1));
+	},
+	merge(layer1, layer2) {
+		return layer1.merge(layer2);
+	}
+};
+
+//#endregion
+//#region src/constant.ts
+/**
+* Creates a layer that provides a constant value for a given tag.
+*
+* @param tag - The value tag to provide
+* @param constantValue - The constant value to provide
+* @returns A layer with no dependencies that provides the constant value
+*
+* @example
+* ```typescript
+* const ApiKey = Tag.of('ApiKey')<string>();
+* const DatabaseUrl = Tag.of('DatabaseUrl')<string>();
+*
+* const apiKey = constant(ApiKey, 'my-secret-key');
+* const dbUrl = constant(DatabaseUrl, 'postgresql://localhost:5432/myapp');
+*
+* const config = Layer.merge(apiKey, dbUrl);
+* ```
+*/
+function constant(tag, constantValue) {
+	return layer((container) => container.register(tag, () => constantValue));
+}
+
+//#endregion
 //#region src/utils/object.ts
 function hasKey(obj, key) {
 	return obj !== void 0 && obj !== null && (typeof obj === "object" || typeof obj === "function") && key in obj;
@@ -45,12 +200,6 @@ const Tag = {
 			[TagTypeKey]: void 0
 		});
 	},
-	for: () => {
-		return {
-			[ValueTagIdKey]: Symbol(),
-			[TagTypeKey]: void 0
-		};
-	},
 	Service: (id) => {
 		class Tagged {
 			static [ServiceTagIdKey] = id;
@@ -97,29 +246,39 @@ var SandlyError = class SandlyError extends Error {
 		super(message, { cause });
 		this.name = this.constructor.name;
 		this.detail = detail;
-		if (cause instanceof Error && cause.stack !== void 0) this.stack = `${this.stack}\nCaused by: ${cause.stack}`;
+		if (cause instanceof Error && cause.stack !== void 0) this.stack = `${this.stack ?? ""}\nCaused by: ${cause.stack}`;
 	}
 	static ensure(error) {
 		return error instanceof SandlyError ? error : new SandlyError("An unknown error occurred", { cause: error });
 	}
 	dump() {
-		const cause = this.cause instanceof SandlyError ? this.cause.dump().error : this.cause;
-		const result = {
-			name: this.name,
-			message: this.message,
-			cause,
-			detail: this.detail ?? {}
-		};
 		return {
 			name: this.name,
-			message: result.message,
+			message: this.message,
 			stack: this.stack,
-			error: result
+			detail: this.detail ?? {},
+			cause: this.dumpCause(this.cause)
 		};
 	}
 	dumps() {
 		return JSON.stringify(this.dump());
 	}
+	/**
+	* Recursively extract cause chain from any Error.
+	* Handles both AppError (with dump()) and plain Errors (with cause property).
+	*/
+	dumpCause(cause) {
+		if (cause instanceof SandlyError) return cause.dump();
+		if (cause instanceof Error) {
+			const result = {
+				name: cause.name,
+				message: cause.message
+			};
+			if ("cause" in cause && cause.cause !== void 0) result.cause = this.dumpCause(cause.cause);
+			return result;
+		}
+		return cause;
+	}
 };
 /**
 * Error thrown when attempting to register a dependency that has already been instantiated.
@@ -370,7 +529,7 @@ const ContainerTypeId = Symbol.for("sandly/Container");
 * at the type level, ensuring that only registered dependencies can be retrieved
 * and preventing runtime errors.
 *
-* @template TReg - Union type of all registered dependency tags in this container
+* @template TTags - Union type of all registered dependency tags in this container
 *
 * @example Basic usage with service tags
 * ```typescript
@@ -436,17 +595,17 @@ var Container = class Container {
 	* Ensures singleton behavior and supports concurrent access.
 	* @internal
 	*/
-	cache = /* @__PURE__ */ new Map();
+	cache = new Map();
 	/**
 	* Factory functions for creating dependency instances.
 	* @internal
 	*/
-	factories = /* @__PURE__ */ new Map();
+	factories = new Map();
 	/**
 	* Finalizer functions for cleaning up dependencies when the container is destroyed.
 	* @internal
 	*/
-	finalizers = /* @__PURE__ */ new Map();
+	finalizers = new Map();
 	/**
 	* Flag indicating whether this container has been destroyed.
 	* @internal
@@ -797,129 +956,93 @@ var Container = class Container {
 };
 
 //#endregion
-//#region src/layer.ts
-/**
-* The type ID for the Layer interface.
-*/
-const LayerTypeId = Symbol.for("sandly/Layer");
+//#region src/dependency.ts
 /**
-* Creates a new dependency layer that encapsulates a set of dependency registrations.
-* Layers are the primary building blocks for organizing and composing dependency injection setups.
+* Creates a layer that provides a single dependency with inferred requirements.
 *
-* @template TRequires - The union of dependency tags this layer requires from other layers or external setup
-* @template TProvides - The union of dependency tags this layer registers/provides
+* This is a simplified alternative to `layer()` for the common case of defining
+* a single dependency. Unlike `service()` and `autoService()`, this works with
+* any tag type (ServiceTag or ValueTag) and doesn't require extending `Tag.Service()`.
 *
-* @param register - Function that performs the dependency registrations. Receives a container.
-* @returns The layer instance.
+* Requirements are passed as an optional array of tags, allowing TypeScript to infer
+* both the tag type and the requirements automatically - no explicit type
+* parameters needed.
 *
-* @example Simple layer
+* @param tag - The tag (ServiceTag or ValueTag) that identifies this dependency
+* @param spec - Factory function or lifecycle object for creating the dependency
+* @param requirements - Optional array of dependency tags this dependency requires (defaults to [])
+* @returns A layer that requires the specified dependencies and provides the tag
+*
+* @example Simple dependency without requirements
 * ```typescript
-* import { layer, Tag } from 'sandly';
+* const Config = Tag.of('Config')<{ apiUrl: string }>();
 *
-* class DatabaseService extends Tag.Service('DatabaseService') {
-*   constructor(private url: string = 'sqlite://memory') {}
-*   query() { return 'data'; }
-* }
+* // No requirements - can omit the array
+* const configDep = dependency(Config, () => ({
+*   apiUrl: process.env.API_URL!
+* }));
+* ```
 *
-* // Layer that provides DatabaseService, requires nothing
-* const databaseLayer = layer<never, typeof DatabaseService>((container) =>
-*   container.register(DatabaseService, () => new DatabaseService())
+* @example Dependency with requirements
+* ```typescript
+* const database = dependency(
+*   Database,
+*   async (ctx) => {
+*     const config = await ctx.resolve(Config);
+*     const logger = await ctx.resolve(Logger);
+*     logger.info('Creating database connection');
+*     return createDb(config.DATABASE);
+*   },
+*   [Config, Logger]
 * );
-*
-* // Usage
-* const dbLayerInstance = databaseLayer;
 * ```
 *
-* @example Complex application layer structure
+* @example Dependency with lifecycle (create + cleanup)
 * ```typescript
-* // Configuration layer
-* const configLayer = layer<never, typeof ConfigTag>((container) =>
-*   container.register(ConfigTag, () => loadConfig())
+* const database = dependency(
+*   Database,
+*   {
+*     create: async (ctx) => {
+*       const config = await ctx.resolve(Config);
+*       const logger = await ctx.resolve(Logger);
+*       logger.info('Creating database connection');
+*       return await createDb(config.DATABASE);
+*     },
+*     cleanup: async (db) => {
+*       await disconnectDb(db);
+*     },
+*   },
+*   [Config, Logger]
 * );
+* ```
 *
-* // Infrastructure layer (requires config)
-* const infraLayer = layer<typeof ConfigTag, typeof DatabaseService | typeof CacheService>(
+* @example Comparison with layer()
+* ```typescript
+* // Using layer() - verbose, requires explicit type parameters
+* const database = layer<typeof Config | typeof Logger, typeof Database>(
 *   (container) =>
-*     container
-*       .register(DatabaseService, async (ctx) => new DatabaseService(await ctx.resolve(ConfigTag)))
-*       .register(CacheService, async (ctx) => new CacheService(await ctx.resolve(ConfigTag)))
+*     container.register(Database, async (ctx) => {
+*       const config = await ctx.resolve(Config);
+*       return createDb(config.DATABASE);
+*     })
 * );
 *
-* // Service layer (requires infrastructure)
-* const serviceLayer = layer<typeof DatabaseService | typeof CacheService, typeof UserService>(
-*   (container) =>
-*     container.register(UserService, async (ctx) =>
-*       new UserService(await ctx.resolve(DatabaseService), await ctx.resolve(CacheService))
-*     )
+* // Using dependency() - cleaner, fully inferred types
+* const database = dependency(
+*   Database,
+*   async (ctx) => {
+*     const config = await ctx.resolve(Config);
+*     return createDb(config.DATABASE);
+*   },
+*   [Config, Logger]
 * );
-*
-* // Compose the complete application
-* const appLayer = serviceLayer.provide(infraLayer).provide(configLayer);
 * ```
 */
-function layer(register) {
-	const layerImpl = {
-		register: (container) => register(container),
-		provide(dependency) {
-			return createProvidedLayer(dependency, layerImpl);
-		},
-		provideMerge(dependency) {
-			return createComposedLayer(dependency, layerImpl);
-		},
-		merge(other) {
-			return createMergedLayer(layerImpl, other);
-		}
-	};
-	return layerImpl;
-}
-/**
-* Internal function to create a provided layer from two layers.
-* This implements the `.provide()` method logic - only exposes target layer's provisions.
-*
-* @internal
-*/
-function createProvidedLayer(dependency, target) {
-	return createComposedLayer(dependency, target);
-}
-/**
-* Internal function to create a composed layer from two layers.
-* This implements the `.provideMerge()` method logic - exposes both layers' provisions.
-*
-* @internal
-*/
-function createComposedLayer(dependency, target) {
+function dependency(tag, spec, requirements) {
 	return layer((container) => {
-		const containerWithDependency = dependency.register(container);
-		return target.register(containerWithDependency);
-	});
-}
-/**
-* Internal function to create a merged layer from two layers.
-* This implements the `.merge()` method logic.
-*
-* @internal
-*/
-function createMergedLayer(layer1, layer2) {
-	return layer((container) => {
-		const container1 = layer1.register(container);
-		const container2 = layer2.register(container1);
-		return container2;
+		return container.register(tag, spec);
 	});
 }
-/**
-* Utility object containing helper functions for working with layers.
-*/
-const Layer = {
-	empty() {
-		return layer((container) => container);
-	},
-	mergeAll(...layers) {
-		return layers.reduce((acc, layer$1) => acc.merge(layer$1));
-	},
-	merge(layer1, layer2) {
-		return layer1.merge(layer2);
-	}
-};
 
 //#endregion
 //#region src/scoped-container.ts
@@ -1199,28 +1322,4 @@ function autoService(tag, spec) {
 }
 
 //#endregion
-//#region src/value.ts
-/**
-* Creates a layer that provides a constant value for a given tag.
-*
-* @param tag - The value tag to provide
-* @param constantValue - The constant value to provide
-* @returns A layer with no dependencies that provides the constant value
-*
-* @example
-* ```typescript
-* const ApiKey = Tag.of('ApiKey')<string>();
-* const DatabaseUrl = Tag.of('DatabaseUrl')<string>();
-*
-* const apiKey = value(ApiKey, 'my-secret-key');
-* const dbUrl = value(DatabaseUrl, 'postgresql://localhost:5432/myapp');
-*
-* const config = Layer.merge(apiKey, dbUrl);
-* ```
-*/
-function value(tag, constantValue) {
-	return layer((container) => container.register(tag, () => constantValue));
-}
-
-//#endregion
-export { CircularDependencyError, Container, ContainerDestroyedError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, InjectSource, Layer, SandlyError, ScopedContainer, Tag, UnknownDependencyError, autoService, layer, service, value };
+export { CircularDependencyError, Container, ContainerDestroyedError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, InjectSource, Layer, SandlyError, ScopedContainer, Tag, UnknownDependencyError, autoService, constant, dependency, layer, service };

package/package.json

@@ -1,75 +1,69 @@
 {
-  "name": "sandly",
-  "version": "0.5.3",
-  "keywords": [
-    "typescript",
-    "sandly",
-    "dependency-injection",
-    "dependency-inversion",
-    "injection",
-    "di",
-    "inversion-of-control",
-    "ioc",
-    "container",
-    "layer",
-    "service",
-    "aws",
-    "lambda",
-    "aws-lambda"
-  ],
-  "homepage": "https://github.com/borisrakovan/sandly",
-  "bugs": {
-    "url": "https://github.com/borisrakovan/sandly/issues"
-  },
-  "author": "Boris Rakovan <b.rakovan@gmail.com> (https://github.com/borisrakovan)",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/borisrakovan/sandly.git"
-  },
-  "license": "MIT",
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "devDependencies": {
-    "@changesets/cli": "^2.29.5",
-    "@eslint/js": "^9.26.0",
-    "@types/aws-lambda": "^8.10.149",
-    "@types/node": "^22.15.3",
-    "@types/node-fetch": "^2.6.12",
-    "dotenv": "^16.5.0",
-    "esbuild": "^0.25.3",
-    "eslint": "^9.26.0",
-    "node-fetch": "^3.3.2",
-    "prettier": "^3.5.3",
-    "prettier-plugin-organize-imports": "^4.1.0",
-    "ts-node": "^10.9.2",
-    "tsdown": "^0.14.1",
-    "tsx": "^4.19.4",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.38.0",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.1.3",
-    "zod": "^4.0.15"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "clean": "rm -rf dist",
-    "watch": "tsc --watch",
-    "format": "prettier --write \"{src,test}/**/*.ts\"",
-    "format:check": "prettier --check \"{src,test}/**/*.ts\"",
-    "lint": "eslint . --fix",
-    "lint:check": "eslint . --max-warnings=0",
-    "type:check": "tsc --noEmit",
-    "test": "vitest run",
-    "release": "changeset version && changeset publish"
-  }
-}
+	"name": "sandly",
+	"version": "1.0.1",
+	"keywords": [
+		"typescript",
+		"sandly",
+		"dependency-injection",
+		"dependency-inversion",
+		"injection",
+		"di",
+		"inversion-of-control",
+		"ioc",
+		"container",
+		"layer",
+		"service",
+		"aws",
+		"lambda",
+		"aws-lambda"
+	],
+	"homepage": "https://github.com/borisrakovan/sandly",
+	"bugs": {
+		"url": "https://github.com/borisrakovan/sandly/issues"
+	},
+	"author": "Boris Rakovan <b.rakovan@gmail.com> (https://github.com/borisrakovan)",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/borisrakovan/sandly.git"
+	},
+	"license": "MIT",
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "tsdown",
+		"clean": "rm -rf dist",
+		"watch": "tsc --watch",
+		"format": "prettier --write \"{src,test}/**/*.ts\"",
+		"format:check": "prettier --check \"{src,test}/**/*.ts\"",
+		"lint": "eslint . --fix",
+		"lint:check": "eslint . --max-warnings=0",
+		"type:check": "tsc --noEmit",
+		"test": "vitest run",
+		"tag": "git tag v$(node -p \"require('./package.json').version\") && git push --tags",
+		"release": "changeset version && changeset publish"
+	},
+	"devDependencies": {
+		"@changesets/cli": "^2.29.5",
+		"@eslint/js": "^9.26.0",
+		"@types/node": "^22.15.3",
+		"eslint": "^9.26.0",
+		"prettier": "^3.5.3",
+		"prettier-plugin-organize-imports": "^4.1.0",
+		"tsdown": "0.11.7",
+		"typescript": "^5.8.3",
+		"typescript-eslint": "^8.38.0",
+		"vite-tsconfig-paths": "^5.1.4",
+		"vitest": "^3.1.3"
+	},
+	"packageManager": "pnpm@9.13.0+sha512.beb9e2a803db336c10c9af682b58ad7181ca0fbd0d4119f2b33d5f2582e96d6c0d93c85b23869295b765170fbdaa92890c0da6ada457415039769edf3c959efe"
+}