@effected/app 0.3.1 → 0.4.1

package/App.js

@@ -15,48 +15,12 @@ const testPaths = () => XdgPaths.make({
 	configDirs: ["/etc/xdg"],
 	dataDirs: ["/usr/local/share", "/usr/share"]
 });
-/**
-* Build the application control plane: namespaced directories, the state
-* database and the cache database, all pointed at the same place.
-*
-* @remarks
-* Composition is `AppDirs.layer(options)` `provideMerge` `Xdg.layer`, with the
-* {@link AppStore} and {@link AppCache} glue `provideMerge`d over the result,
-* so all four services come out and only `FileSystem` and `Path` stay in `R` —
-* the two the consumer's platform layer supplies once, at the edge.
-*
-* `App.layer` always provides **both** databases: an application that wants
-* only one composes `AppStore.layer` or `AppCache.layer` directly and never
-* opens the other file. Passing no `cache` options still opens `cache.db`,
-* because `CacheOptions` are all-optional and absence means defaults.
-*
-* This is a layer-returning function: bind the result to a `const` once and
-* reuse that binding. Calling it inline at two provide sites opens two
-* databases — two connections onto one file, two migration ledgers, and two
-* independent `CacheEvent` PubSubs whose subscribers each see half the events.
-*/
 const layer = (options) => {
 	const { store, cache, ...dirOptions } = options;
 	const dirs = Layer.provideMerge(AppDirs.layer(dirOptions), Xdg.layer);
 	const databases = Layer.mergeAll(AppStore.layer(store), AppCache.layer(cache));
 	return Layer.provideMerge(databases, dirs);
 };
-/**
-* The hermetic control plane: fixed XDG paths, `:memory:` databases, and the
-* platform layers provided internally.
-*
-* @remarks
-* `Xdg.layerFrom` over a synthetic default {@link XdgPaths}, `Store.layerTest`
-* and `Cache.layerTest`, with `Path.layer` and `FileSystem.layerNoop` provided
-* **internally** via `Layer.provide` — not merged into the output, not
-* exposed. A consumer's first test needs no platform package at all.
-*
-* The documented limit: code paths that actually exercise `ensure*` **die**
-* against `FileSystem.layerNoop` — it is a stub, not a working filesystem.
-* `layerTest` is for testing logic that *uses* the control plane; a test of
-* real directory behaviour uses {@link (App:variable).layer} with a
-* temp-directory `HOME`.
-*/
 const layerTest = (options) => {
 	const dirs = Layer.provideMerge(AppDirs.layer({ namespace: options.namespace }), Xdg.layerFrom(options.paths ?? testPaths()));
 	const databases = Layer.mergeAll(Store.layerTest(options.store ?? { migrations: [] }), Cache.layerTest(options.cache));
@@ -68,9 +32,46 @@ const layerTest = (options) => {
 *
 * @public
 */
-const App = {
-	layer,
-	layerTest
+var App = class {
+	constructor() {}
+	/**
+	* Build the application control plane: namespaced directories, the state
+	* database and the cache database, all pointed at the same place.
+	*
+	* @remarks
+	* Composition is `AppDirs.layer(options)` `provideMerge` `Xdg.layer`, with the
+	* {@link AppStore} and {@link AppCache} glue `provideMerge`d over the result,
+	* so all four services come out and only `FileSystem` and `Path` stay in `R` —
+	* the two the consumer's platform layer supplies once, at the edge.
+	*
+	* `App.layer` always provides **both** databases: an application that wants
+	* only one composes `AppStore.layer` or `AppCache.layer` directly and never
+	* opens the other file. Passing no `cache` options still opens `cache.db`,
+	* because `CacheOptions` are all-optional and absence means defaults.
+	*
+	* This is a layer-returning function: bind the result to a `const` once and
+	* reuse that binding. Calling it inline at two provide sites opens two
+	* databases — two connections onto one file, two migration ledgers, and two
+	* independent `CacheEvent` PubSubs whose subscribers each see half the events.
+	*/
+	static layer = layer;
+	/**
+	* The hermetic control plane: fixed XDG paths, `:memory:` databases, and the
+	* platform layers provided internally.
+	*
+	* @remarks
+	* `Xdg.layerFrom` over a synthetic default `XdgPaths`, `Store.layerTest`
+	* and `Cache.layerTest`, with `Path.layer` and `FileSystem.layerNoop` provided
+	* **internally** via `Layer.provide` — not merged into the output, not
+	* exposed. A consumer's first test needs no platform package at all.
+	*
+	* The documented limit: code paths that actually exercise `ensure*` **die**
+	* against `FileSystem.layerNoop` — it is a stub, not a working filesystem.
+	* `layerTest` is for testing logic that *uses* the control plane; a test of
+	* real directory behaviour uses {@link App.layer} with a temp-directory
+	* `HOME`.
+	*/
+	static layerTest = layerTest;
 };
 
 //#endregion

package/AppCache.js

@@ -4,20 +4,6 @@ import { AppDirs } from "@effected/xdg";
 import { Effect, Layer, Path } from "effect";
 
 //#region src/AppCache.ts
-/**
-* Build the cache-directory database layer: `AppDirs.ensureCache`, then
-* `Cache.layerSqlite` at `<cache dir>/<filename>`.
-*
-* @remarks
-* The same ensure-before-open ordering as `AppStore.layer`, and it matters
-* *more* here: the cache directory is the one an operator is most likely to
-* have deleted between runs. `options` is optional because every
-* `CacheOptions` field is.
-*
-* This is a layer-returning function: bind the result to a `const` and reuse
-* that binding, or memoization by reference is lost and the database is
-* opened twice.
-*/
 const layer = (options) => Layer.unwrap(Effect.gen(function* () {
 	const opts = options ?? {};
 	const filename = opts.filename ?? "cache.db";
@@ -37,7 +23,24 @@ const layer = (options) => Layer.unwrap(Effect.gen(function* () {
 *
 * @public
 */
-const AppCache = { layer };
+var AppCache = class {
+	constructor() {}
+	/**
+	* Build the cache-directory database layer: `AppDirs.ensureCache`, then
+	* `Cache.layerSqlite` at `<cache dir>/<filename>`.
+	*
+	* @remarks
+	* The same ensure-before-open ordering as `AppStore.layer`, and it matters
+	* *more* here: the cache directory is the one an operator is most likely to
+	* have deleted between runs. `options` is optional because every
+	* `CacheOptions` field is.
+	*
+	* This is a layer-returning function: bind the result to a `const` and reuse
+	* that binding, or memoization by reference is lost and the database is
+	* opened twice.
+	*/
+	static layer = layer;
+};
 
 //#endregion
 export { AppCache };

package/AppConfig.js

@@ -4,25 +4,6 @@ import { Effect, Layer } from "effect";
 import { ConfigFile, MergeStrategy } from "@effected/config-file";
 
 //#region src/AppConfig.ts
-/**
-* Build the xdg-flavored config layer for a `ConfigFile.Service` class.
-*
-* @remarks
-* Wraps `ConfigFile.layer(tag, …)` with the resolver chain xdg documents, in
-* xdg's documented order — `XdgConfig.resolver`, then
-* `XdgConfig.nativeResolver` — and with `defaultPath:
-* XdgConfig.savePath(filename)`, which fits config-file's infallible
-* `defaultPath` slot without an `orDie` because xdg resolves at
-* layer-construction time.
-*
-* **The namespace is never a parameter.** It is read from the ambient
-* {@link AppDirs} service at layer build time, so it is typed exactly once, in
-* `App.layer` — the two-strings drift where an app passes `"myapp"` to
-* `App.layer` and `"my-app"` to its config preset cannot happen.
-*
-* This is a layer-returning function: bind the result to a `const` and reuse
-* that binding, or two provide sites mint two independent service instances.
-*/
 const layer = (tag, options) => Layer.unwrap(Effect.gen(function* () {
 	const invalid = badFilename("AppConfig.layer", options.filename);
 	if (invalid !== void 0) return yield* Effect.die(invalid);
@@ -54,7 +35,28 @@ const layer = (tag, options) => Layer.unwrap(Effect.gen(function* () {
 *
 * @public
 */
-const AppConfig = { layer };
+var AppConfig = class {
+	constructor() {}
+	/**
+	* Build the xdg-flavored config layer for a `ConfigFile.Service` class.
+	*
+	* @remarks
+	* Wraps `ConfigFile.layer(tag, …)` with the resolver chain xdg documents, in
+	* xdg's documented order — `XdgConfig.resolver`, then `XdgConfig.nativeResolver`
+	* — and with `defaultPath: XdgConfig.savePath(filename)`, which fits
+	* config-file's infallible `defaultPath` slot without an `orDie` because xdg
+	* resolves at layer-construction time.
+	*
+	* **The namespace is never a parameter.** It is read from the ambient
+	* `AppDirs` service at layer build time, so it is typed exactly once, in
+	* `App.layer` — the two-strings drift where an app passes `"myapp"` to
+	* `App.layer` and `"my-app"` to its config preset cannot happen.
+	*
+	* This is a layer-returning function: bind the result to a `const` and reuse
+	* that binding, or two provide sites mint two independent service instances.
+	*/
+	static layer = layer;
+};
 
 //#endregion
 export { AppConfig };

package/AppStore.js

@@ -4,23 +4,6 @@ import { AppDirs } from "@effected/xdg";
 import { Effect, Layer, Path } from "effect";
 
 //#region src/AppStore.ts
-/**
-* Build the state-directory database layer: `AppDirs.ensureState`, then
-* `Store.layerSqlite` at `<state dir>/<filename>`.
-*
-* @remarks
-* The ensure-before-open ordering is the load-bearing glue.
-* `SqliteClient.layer` has no error channel and **defects** on a missing
-* parent directory; `AppDirs.ensureState` is a `mkdir -p` on a **typed**
-* `AppDirsError` channel. Running the ensure inside `Layer.unwrap`, before the
-* store layer is built, converts a defect surface into a typed one — "the
-* state directory could not be created" is an expected, recoverable boundary
-* failure and it stays on `E`. Nothing is `orDie`d.
-*
-* This is a layer-returning function: bind the result to a `const` and reuse
-* that binding, or memoization by reference is lost and the database is
-* opened twice.
-*/
 const layer = (options) => Layer.unwrap(Effect.gen(function* () {
 	const filename = options.filename ?? "store.db";
 	const invalid = badFilename("AppStore.layer", filename);
@@ -39,7 +22,27 @@ const layer = (options) => Layer.unwrap(Effect.gen(function* () {
 *
 * @public
 */
-const AppStore = { layer };
+var AppStore = class {
+	constructor() {}
+	/**
+	* Build the state-directory database layer: `AppDirs.ensureState`, then
+	* `Store.layerSqlite` at `<state dir>/<filename>`.
+	*
+	* @remarks
+	* The ensure-before-open ordering is the load-bearing glue.
+	* `SqliteClient.layer` has no error channel and **defects** on a missing
+	* parent directory; `AppDirs.ensureState` is a `mkdir -p` on a **typed**
+	* `AppDirsError` channel. Running the ensure inside `Layer.unwrap`, before the
+	* store layer is built, converts a defect surface into a typed one — "the
+	* state directory could not be created" is an expected, recoverable boundary
+	* failure and it stays on `E`. Nothing is `orDie`d.
+	*
+	* This is a layer-returning function: bind the result to a `const` and reuse
+	* that binding, or memoization by reference is lost and the database is
+	* opened twice.
+	*/
+	static layer = layer;
+};
 
 //#endregion
 export { AppStore };

package/index.d.ts

@@ -4,7 +4,7 @@ import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
 import { ConfigCodec, ConfigEvents, ConfigEventsShape, ConfigFileShape, ConfigValidationError, MergeStrategy } from "@effected/config-file";
 //#region src/AppCache.d.ts
 /**
- * Options for {@link (AppCache:variable).layer}.
+ * Options for {@link AppCache.layer}.
  *
  * @public
  */
@@ -25,13 +25,28 @@ interface AppCacheOptions extends CacheOptions {
  *
  * @public
  */
-declare const AppCache: {
-  readonly layer: (options?: AppCacheOptions) => Layer.Layer<Cache, AppDirsError | CacheError, AppDirs | Path.Path>;
-};
+declare class AppCache {
+  private constructor();
+  /**
+   * Build the cache-directory database layer: `AppDirs.ensureCache`, then
+   * `Cache.layerSqlite` at `<cache dir>/<filename>`.
+   *
+   * @remarks
+   * The same ensure-before-open ordering as `AppStore.layer`, and it matters
+   * *more* here: the cache directory is the one an operator is most likely to
+   * have deleted between runs. `options` is optional because every
+   * `CacheOptions` field is.
+   *
+   * This is a layer-returning function: bind the result to a `const` and reuse
+   * that binding, or memoization by reference is lost and the database is
+   * opened twice.
+   */
+  static readonly layer: (options?: AppCacheOptions) => Layer.Layer<Cache, AppDirsError | CacheError, AppDirs | Path.Path>;
+}
 //#endregion
 //#region src/AppStore.d.ts
 /**
- * Options for {@link (AppStore:variable).layer}.
+ * Options for {@link AppStore.layer}.
  *
  * @public
  */
@@ -52,9 +67,27 @@ interface AppStoreOptions extends StoreOptions {
  *
  * @public
  */
-declare const AppStore: {
-  readonly layer: (options: AppStoreOptions) => Layer.Layer<Store, AppDirsError | StoreError | StoreMigrationError, AppDirs | Path.Path>;
-};
+declare class AppStore {
+  private constructor();
+  /**
+   * Build the state-directory database layer: `AppDirs.ensureState`, then
+   * `Store.layerSqlite` at `<state dir>/<filename>`.
+   *
+   * @remarks
+   * The ensure-before-open ordering is the load-bearing glue.
+   * `SqliteClient.layer` has no error channel and **defects** on a missing
+   * parent directory; `AppDirs.ensureState` is a `mkdir -p` on a **typed**
+   * `AppDirsError` channel. Running the ensure inside `Layer.unwrap`, before the
+   * store layer is built, converts a defect surface into a typed one — "the
+   * state directory could not be created" is an expected, recoverable boundary
+   * failure and it stays on `E`. Nothing is `orDie`d.
+   *
+   * This is a layer-returning function: bind the result to a `const` and reuse
+   * that binding, or memoization by reference is lost and the database is
+   * opened twice.
+   */
+  static readonly layer: (options: AppStoreOptions) => Layer.Layer<Store, AppDirsError | StoreError | StoreMigrationError, AppDirs | Path.Path>;
+}
 //#endregion
 //#region src/App.d.ts
 /**
@@ -72,7 +105,7 @@ declare const AppStore: {
  */
 type AppError = XdgEnvError | AppDirsError | StoreError | StoreMigrationError | CacheError;
 /**
- * Options for {@link (App:variable).layer}.
+ * Options for {@link App.layer}.
  *
  * @remarks
  * The `AppDirsOptions` fields — `namespace`, `native`, `fallbackDir`, `dirs` —
@@ -88,7 +121,7 @@ interface AppOptions extends AppDirsOptions {
   readonly cache?: AppCacheOptions;
 }
 /**
- * Options for {@link (App:variable).layerTest}.
+ * Options for {@link App.layerTest}.
  *
  * @public
  */
@@ -108,14 +141,51 @@ interface AppTestOptions {
  *
  * @public
  */
-declare const App: {
-  readonly layer: (options: AppOptions) => Layer.Layer<Xdg | AppDirs | Store | Cache, AppError, FileSystem.FileSystem | Path.Path>;
-  readonly layerTest: (options: AppTestOptions) => Layer.Layer<Xdg | AppDirs | Store | Cache, AppError>;
-};
+declare class App {
+  private constructor();
+  /**
+   * Build the application control plane: namespaced directories, the state
+   * database and the cache database, all pointed at the same place.
+   *
+   * @remarks
+   * Composition is `AppDirs.layer(options)` `provideMerge` `Xdg.layer`, with the
+   * {@link AppStore} and {@link AppCache} glue `provideMerge`d over the result,
+   * so all four services come out and only `FileSystem` and `Path` stay in `R` —
+   * the two the consumer's platform layer supplies once, at the edge.
+   *
+   * `App.layer` always provides **both** databases: an application that wants
+   * only one composes `AppStore.layer` or `AppCache.layer` directly and never
+   * opens the other file. Passing no `cache` options still opens `cache.db`,
+   * because `CacheOptions` are all-optional and absence means defaults.
+   *
+   * This is a layer-returning function: bind the result to a `const` once and
+   * reuse that binding. Calling it inline at two provide sites opens two
+   * databases — two connections onto one file, two migration ledgers, and two
+   * independent `CacheEvent` PubSubs whose subscribers each see half the events.
+   */
+  static readonly layer: (options: AppOptions) => Layer.Layer<Xdg | AppDirs | Store | Cache, AppError, FileSystem.FileSystem | Path.Path>;
+  /**
+   * The hermetic control plane: fixed XDG paths, `:memory:` databases, and the
+   * platform layers provided internally.
+   *
+   * @remarks
+   * `Xdg.layerFrom` over a synthetic default `XdgPaths`, `Store.layerTest`
+   * and `Cache.layerTest`, with `Path.layer` and `FileSystem.layerNoop` provided
+   * **internally** via `Layer.provide` — not merged into the output, not
+   * exposed. A consumer's first test needs no platform package at all.
+   *
+   * The documented limit: code paths that actually exercise `ensure*` **die**
+   * against `FileSystem.layerNoop` — it is a stub, not a working filesystem.
+   * `layerTest` is for testing logic that *uses* the control plane; a test of
+   * real directory behaviour uses {@link App.layer} with a temp-directory
+   * `HOME`.
+   */
+  static readonly layerTest: (options: AppTestOptions) => Layer.Layer<Xdg | AppDirs | Store | Cache, AppError>;
+}
 //#endregion
 //#region src/AppConfig.d.ts
 /**
- * Options for {@link (AppConfig:variable).layer}.
+ * Options for {@link AppConfig.layer}.
  *
  * @public
  */
@@ -171,9 +241,28 @@ interface AppConfigOptions<A, I> {
  *
  * @public
  */
-declare const AppConfig: {
-  readonly layer: <Self, A, I>(tag: Context.Key<Self, ConfigFileShape<A>>, options: AppConfigOptions<A, I>) => Layer.Layer<Self, never, FileSystem.FileSystem | Path.Path | AppDirs | Xdg>;
-};
+declare class AppConfig {
+  private constructor();
+  /**
+   * Build the xdg-flavored config layer for a `ConfigFile.Service` class.
+   *
+   * @remarks
+   * Wraps `ConfigFile.layer(tag, …)` with the resolver chain xdg documents, in
+   * xdg's documented order — `XdgConfig.resolver`, then `XdgConfig.nativeResolver`
+   * — and with `defaultPath: XdgConfig.savePath(filename)`, which fits
+   * config-file's infallible `defaultPath` slot without an `orDie` because xdg
+   * resolves at layer-construction time.
+   *
+   * **The namespace is never a parameter.** It is read from the ambient
+   * `AppDirs` service at layer build time, so it is typed exactly once, in
+   * `App.layer` — the two-strings drift where an app passes `"myapp"` to
+   * `App.layer` and `"my-app"` to its config preset cannot happen.
+   *
+   * This is a layer-returning function: bind the result to a `const` and reuse
+   * that binding, or two provide sites mint two independent service instances.
+   */
+  static readonly layer: <Self, A, I>(tag: Context.Key<Self, ConfigFileShape<A>>, options: AppConfigOptions<A, I>) => Layer.Layer<Self, never, FileSystem.FileSystem | Path.Path | AppDirs | Xdg>;
+}
 //#endregion
 export { App, AppCache, type AppCacheOptions, AppConfig, type AppConfigOptions, type AppError, type AppOptions, AppStore, type AppStoreOptions, type AppTestOptions };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/app",
-	"version": "0.3.1",
+	"version": "0.4.1",
 	"private": false,
 	"description": "The application control plane for Effect: one layer wiring XDG-namespaced directories, a migrated SQLite store, a TTL cache and a config file to the same place.",
 	"keywords": [
@@ -39,9 +39,9 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/config-file": "~0.1.9",
+		"@effected/config-file": "~0.2.0",
 		"@effected/store": "~0.1.2",
-		"@effected/xdg": "~0.1.8",
+		"@effected/xdg": "~0.1.9",
 		"effect": "4.0.0-beta.101"
 	},
 	"engines": {