vla 0.1.1

package/README.md

@@ -0,0 +1,356 @@
+# capsel
+
+A TypeScript data layer kernel for backend- and fullstack apps. Compatible with whatever framework or library you're using.
+
+🚧 WIP, under development. Exports and names will very likely change often.
+
+- Dependency Injection without decorators and without reflection
+- Works in any server-side framework
+- Write code that's easy to test without module mocks all over the place
+- Structures code into modules, layers and interfaces
+- Familiar patterns: Actions, Services, Repos, Facades
+- Ensures that Facades are used for cross-module dependencies to prevent messy code dependencies
+- Tree shakeable
+- Memoziation for Repos
+- request-based context with AsyncLocalStorage
+- 🏗️ first-class context injection
+- ...
+
+## Why?
+
+Many fullstack frameworks lack structure and conventions on the backend side (data layer), but they have lots of good structure and conventions on the frontend side (presentation layer). They are still great frameworks and they all have their own strengths. This is where Capsel comes in. It aims to fill in the missing gap in the data layer, allowing you to write well-structured maintainable, scalable and testable code.
+
+## Usage
+
+```ts
+import { createModule, Kernel } from "capsel"
+
+// Users
+const UserModule = createModule("User")
+
+class ShowUserSettingsAction extends UserModule.Action {
+  users = this.inject(UserService)
+
+  async handle(userId: string) {
+    const settings = await this.users.getSettings(userId)
+    return {
+      timezone: settings.timezone,
+      hasSubscription: settings.hasSubscription
+    }
+  }
+}
+
+class UserService extends UserModule.Service {
+  repo = this.inject(UserRepo)
+  billing = this.inject(BillingFacade)
+  ctx = this.inject(Context) // WIP unimplemented
+
+  async getSettings(userId: string) {
+    await canViewProfile(userId)
+
+    const profile = await this.repo.findById(userId)
+    const hasSubscription = await this.billing.hasSubscription(userId)
+
+    return {
+      ...profile,
+      hasSubscription
+    }
+  }
+
+  private canViewProfile(userId: string) {
+    const isSameUser = this.ctx.currentUser.id !== userId
+    if (!isSameUser) throw new Forbidden()
+
+    // repo method calls are memoized
+    const profile = await this.repo.findById(userId)
+    const isTeamAdmin =
+      this.ctx.currentUser.role === "admin" &&
+      this.ctx.currentUser.teamId === profile.teamId
+
+    if (!isTeamAdmin) throw new Forbidden()
+  }
+}
+
+class UserRepo extends UserModule.Repo {
+  findById = this.memo((id: string) => {
+    // this method is memoized per request.
+    // memoized methods can be called like any normal method, but
+    // if it's called multiple times with the same args, it's only
+    // executed once and the result is cached
+    return db.users.find({ id })
+  })
+
+  async create(data: UserValues) {
+    const createdUser = await db.users.create({ data })
+
+    this.findById.prime(createUser.id).value(createdUser)
+    // memoized methods support multiple utilities:
+    // - .fresh(args) to skip memoized cache and execute the function again
+    // - .prime(args).value({ ... }) to set a cached value
+    // - .preload(args) to run the method in the background and preload the cache
+    // - .bust(args) to bust the cache for the provided args
+    // - .bustAll() to bust the cache for all args
+
+    return createdUser
+  }
+}
+
+// Billing
+const BillingModule = createModule("Billing")
+
+class BillingFacade extends Billing.Facade {
+  repo = this.inject(BillingRepo)
+
+  async hasSubscription(userId: string) {
+    const subscription = await this.repo.findSubscriptionByUser(userId)
+    return Boolean(subscription)
+  }
+}
+
+class BillingRepo extends BillingModule.Repo {
+  async findSubscriptionByUser(userId: string) {
+    return db.subscriptions.find({ userId })
+  }
+}
+
+const kernel = new Kernel()
+kernel.setGlobal() // global instance
+
+const settings = await ShowUserSettingsAction.invoke(userId)
+// -> { timezone: 'GMT+1', hasSubscription: true }
+```
+
+### React usage
+
+```tsx
+import { cache } from 'react'
+import { setCurrentKernelFn } from 'capsel'
+import { kernel } from '@/data/kernel'
+
+const kernel = new Kernel()
+
+// React's cache() will return a new scoped kernel for each request, giving
+// us a new scoped kernel per request without a middleware
+setCurrentKernelFn(cache(() => kernel.scoped()))
+
+async function Layout() {
+  const settings = await ShowUserSettingsAction.invoke(userId)
+
+  return <div><Page /></div>
+}
+
+async function Page() {
+  const settings = await ShowUserSettingsAction.invoke(userId)
+  // it will not query the db twice. it will use the memoized db query
+
+  return (
+    <ul>
+      <li>Timezone: {settings.timezone}</li>
+      <li>Subscriber: {settings.hasSubscription ? "yes" : "no"}</li>
+    </ul>
+  )
+}
+```
+
+### In any middleware-based app
+
+e.g. sveltekit
+
+```ts
+import { runWithScope } from "capsel"
+import type { Handle } from "@sveltejs/kit"
+import { kernel } from '@/data/kernel'
+
+export const handle: Handle = async ({ event, resolve }) => {
+  return runWithScope(kernel.scoped(), () => resolve(event))
+}
+
+import { kernel } from '@/data/kernel';
+import type { PageServerLoad } from './$types';
+
+export const load: PageServerLoad = async ({ params }) => {
+  return {
+    settings: await ShowUserSettingsAction.invoke(userId)
+  }
+}
+```
+
+e.g. express
+
+```ts
+import { runWithScope } from "capsel"
+import { kernel } from '@/data/kernel'
+
+const app = express()
+
+express.use((req, res, next) => runWithScope(kernel.scoped(), () => next()))
+
+app.get("/users/:id", async (req, res) => {
+  const settings = await ShowUserSettingsAction.invoke(req.params.id)
+  res.json({ data: settings })
+})
+```
+
+### Testing
+
+```ts
+test("returns some user settings", async () => {
+  const kernel = new Kernel()
+
+  // mocks for database calls
+  kernel.bind(
+    UserRepo,
+    vi.fn(
+      class {
+        findById = vi.fn().mockResolvedValue({ timezone: "faked" })
+      },
+    ),
+  )
+
+  // mocks for cross-module dependencies
+  kernel.bind(
+    BillingFacade,
+    vi.fn(
+      class {
+        hasSubscription = vi.fn().mockResolvedValue(true)
+      },
+    ),
+  )
+
+  await expect(ShowUserSettingsAction.withKernel(kernel).invoke("1")).resolves.toEqual({
+    timezone: "faked",
+    hasSubscription: true
+  })
+})
+```
+
+## Docs
+
+There aren't any docs yet. This section is just jotting down some notes for myself.
+
+### When to use modules?
+
+You don't need to create a module for each separate resource. Modules are meant for domain separation, not necessarily for resources. Smaller apps may just need a single `AppModule`. Start with a single AppModule and grow.
+
+A module can have multiple services, repositories and even multiple facades to separate resources from each other.
+
+### What's a facade, when to use it?
+
+Facades are meant as the internal public API to a module, for other modules. When one module wants to call something from another module, it should do so through a facade, and not by deeply calling a service or repository of a module. Even though this adds a layer of indirection, it lets you better differentiate between internal and external concerns of a module, and prevents code dependencies from becoming messy. If you use facades excessively often, your domain modelling could be improved.
+
+### How should I structure files and folders?
+
+Roughly follow how capsel structures your code:
+
+- Use separate folders for separate modules
+- Create a separate file for each Service, Repo, Facade, Action
+- You could also have all actions of a resource in a single file
+- If you further want to group files inside a module, do it either by resource (`user`, `post`, etc) or by type (`services`, `repos`, `actions`, etc). Start by having a flat hierarchy with all files of a module in a single folder, and separate into multiple folders once you feel it grew too much.
+
+If you use multiple modules, it's good to separate them into different folders. This allows you to see: if you're importing unproportionally many files from other folders, you have lots of cross-module dependencies, and your data modelling into modules could be improved. 
+
+"How to structure code into files and folders" is often a question of how to manage code dependencies in a way that scales well. Capsel's structure already manages your code dependencies, so it makes sense to align your files and folders on capsel's structure.
+
+### Class scopes
+
+Capsel uses dependency injection to load and use classes in other classes. This means that Capsel creates class instances for you and caches them in different caches for different lifetimes. Whenever you call `inject()`, capsel checks the scope of the class and whether an instance is already cached.
+
+There are 3 different scopes:
+
+- `transient` creates a new instance every time, it does not use a cached instance
+- `invoke` creates a new instance per request handler and reuses this cached instance within the request. 
+- `singleton` creates a new instance only once and caches it forever
+
+Example:
+
+```ts
+class DatabasePool extends MyModule.Singleton {
+  // singletons are cached globally
+  private dbPool: DbPool | null = null
+
+  get dbPool() {
+    return this.dbPool || new DbPool()
+  }
+}
+
+class Repo extends MyModule.Repo {
+  // repos are cached per request (`invoke`)
+
+  // it will only create the db pool once and reuse it
+  // through the application's whole lifetime
+  dbPool = this.inject(DatabasePool)
+
+  private cache = Map<string, User>()
+
+  async findById(id: string) {
+    const cached = this.cache.get(id)
+    if (cached) return cached
+
+    const user = await dbPool.user.find({ id })
+    this.cache.set(id, user)
+    return user
+  }
+}
+
+class ServiceA extends MyModule.Service {
+  // it will use the same instance that ServiceB is also using
+  repo = this.inject(Repo)
+
+  async doSomething() {
+    await this.repo.findById("1")
+  }
+}
+
+class ServiceB extends MyModule.Service {
+  // it will use the same instance that ServiceA is also using
+  repo = this.inject(Repo)
+
+  async doOtherThing() {
+    await this.repo.findById("1")
+  }
+}
+```
+
+In this example:
+- The Database Pool will only be created once and will be reused forever
+- The Repo is stateful for each request. The Repo cache can be shared across all usages
+- The Services can both call the Repo and use the same instance
+
+### Overriding class scopes
+
+```ts
+class FooClass extends MyModule.Class {
+  static scope = FooClass.SingletonScope
+}
+```
+
+You _can_ override the default scope of a Repo, Service, etc. But it's better to create a new BaseClass to not confuse things.
+
+### Defining scope when injecting a class
+
+Example:
+
+```ts
+class FooRepo extends MyModule.Repo {
+  async foo() {}
+}
+
+class FooService extends MyModule.Service {
+  repo = this.inject(FooRepo, "transient")
+}
+```
+
+This will use a transient version of the FooRepo only for the `FooService`. Meaning this service won't share the same cached version that other services might be using.
+
+It's not something you'll likely need to use at all. But this shows how the scope defines how long the instance should be cached and shared.
+
+### Base classes
+
+Capsel gives you multiple base classes to choose from. You can use them as they are or extend them for your own custom base classes.
+
+- `Class` is a generic class with scope `transient`
+- `Singleton` is a `Class` with scope `singleton`
+- `Service` is a `Class` with scope `invoke`
+- `Repo` is a `Memoizable(Class)` with scope `invoke`
+- `Facade` is a named alias for `Class`
+- `Action` is a special class with scope `transient`, where you implement a `handle()` function.

package/dist/index.d.mts

@@ -0,0 +1,138 @@
+//#region src/types.d.ts
+type Scope = "singleton" | "invoke" | "transient";
+type InstantiableClass<T> = new () => T;
+//#endregion
+//#region src/kernel.d.ts
+type Token<T = unknown> = InstantiableClass<T> & {
+  readonly scope?: Scope;
+};
+type Ctor<T = unknown> = InstantiableClass<T> & {
+  readonly scope?: Scope;
+};
+declare class Kernel {
+  private readonly singletons;
+  private readonly invokeCache;
+  private readonly bindings;
+  private readonly parent?;
+  private readonly root;
+  constructor(opts?: {
+    parent?: Kernel;
+  });
+  private fork;
+  private getBinding;
+  bind<T>(key: Token<T>, impl: Ctor<unknown>, scope?: Scope): void;
+  resolve<T>(key: Token<T>, scope?: Scope): T;
+  scoped(): Kernel;
+  create<T>(cls: Ctor<T>): T;
+  private instantiate;
+  private injectInto;
+}
+//#endregion
+//#region src/kernel-als.d.ts
+declare function runWithKernel<T>(scopedKernel: Kernel, fn: () => T): T;
+//#endregion
+//#region src/kernel-current.d.ts
+type CurrentKernelFn = () => Kernel;
+declare function setCurrentKernelFn(fnKernel: CurrentKernelFn): void;
+//#endregion
+//#region src/kernel-global.d.ts
+declare function setGlobalKernel(kernel: Kernel): void;
+//#endregion
+//#region src/memo.d.ts
+type ArgsTuple = unknown[];
+type Memoized<Args extends ArgsTuple, R> = ((...args: Args) => R) & {
+  memoized: (...args: Args) => R;
+  fresh: (...args: Args) => R;
+  prime: (...args: Args) => {
+    value: (value: R) => void;
+  };
+  preload: (...args: Args) => R;
+  bust: (...args: Args) => void;
+  bustAll: () => void;
+};
+//#endregion
+//#region src/modules.d.ts
+declare const BRAND: unique symbol;
+type Layer = "facade" | "service" | "repo" | "action" | "other";
+type Branded<ModuleName extends string, LayerName extends Layer> = {
+  readonly [BRAND]: ClassBrand<ModuleName, LayerName>;
+};
+type Scoped = {
+  readonly scope: Scope;
+};
+type ModuleClass<ModuleName extends string, LayerName extends Layer = Layer> = InstantiableClass<unknown> & Branded<ModuleName, LayerName> & Scoped;
+type LayerOf<T> = T extends ModuleClass<string, infer L> ? L : never;
+type ForbiddenCrossModuleClass = ModuleClass<string, Exclude<Layer, "facade">>;
+type AllowedDependency<ModuleName extends string, Key> = Key extends ModuleClass<ModuleName, Layer> ? Key : Key extends ForbiddenCrossModuleClass ? `Cross-module ${Capitalize<LayerOf<Key>>} injection is not allowed. Use a Facade.` : Key;
+declare class ClassBrand<ModuleName extends string, LayerName extends Layer> {
+  readonly moduleName: ModuleName;
+  readonly layerName: LayerName;
+  constructor(moduleName: ModuleName, layerName: LayerName);
+}
+declare function createModule<const ModuleName extends string>(moduleName: ModuleName): {
+  Facade: (abstract new () => {
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  }) & {
+    scope: Scope;
+    readonly [BRAND]: ClassBrand<ModuleName, "facade">;
+    InvokeScope: Scope;
+    TransientScope: Scope;
+    SingletonScope: Scope;
+  };
+  Service: (abstract new () => {
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  }) & {
+    scope: Scope;
+    readonly [BRAND]: ClassBrand<ModuleName, "service">;
+    InvokeScope: Scope;
+    TransientScope: Scope;
+    SingletonScope: Scope;
+  };
+  Repo: (abstract new () => {
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    memo<Args extends unknown[], R>(fn: (...args: Args) => R): Memoized<Args, R>;
+  }) & {
+    scope: Scope;
+    readonly [BRAND]: ClassBrand<ModuleName, "repo">;
+  };
+  Action: (abstract new () => {
+    handle(...args: unknown[]): unknown | Promise<unknown>;
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  }) & {
+    scope: Scope;
+    invoke<TAction extends {
+      handle(...args: unknown[]): unknown | Promise<unknown>;
+      inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    }, TResult = ReturnType<TAction["handle"]>>(this: new () => TAction, ...args: Parameters<TAction["handle"]>): TResult;
+    withKernel<TAction extends {
+      handle(...args: unknown[]): unknown | Promise<unknown>;
+      inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+    }>(this: new () => TAction, kernel: Kernel): {
+      invoke<TResult = ReturnType<TAction["handle"]>>(...args: Parameters<TAction["handle"]>): TResult;
+    };
+    readonly [BRAND]: ClassBrand<ModuleName, "action">;
+    InvokeScope: Scope;
+    TransientScope: Scope;
+    SingletonScope: Scope;
+  };
+  Singleton: (abstract new () => {
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  }) & {
+    scope: Scope;
+    readonly [BRAND]: ClassBrand<ModuleName, "other">;
+    InvokeScope: Scope;
+    TransientScope: Scope;
+    SingletonScope: Scope;
+  };
+  Class: (abstract new () => {
+    inject: <TKey extends ModuleClass<string>>(key: AllowedDependency<ModuleName, TKey>, scope?: Scope) => InstanceType<TKey>;
+  }) & {
+    scope: Scope;
+    readonly [BRAND]: ClassBrand<ModuleName, "other">;
+    InvokeScope: Scope;
+    TransientScope: Scope;
+    SingletonScope: Scope;
+  };
+};
+//#endregion
+export { Kernel, createModule, runWithKernel, setCurrentKernelFn, setGlobalKernel };

package/dist/index.mjs

@@ -0,0 +1,231 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import objectHash from "object-hash";
+
+//#region src/dependencies.ts
+var UnresolvedDependency = class {
+	constructor(token, scope) {
+		this.token = token;
+		this.scope = scope;
+	}
+};
+function tokenizedDependency(defaultClass, scope) {
+	return new UnresolvedDependency(defaultClass, scope);
+}
+function getInjectionPoint(v) {
+	if (v instanceof UnresolvedDependency) return v;
+	return null;
+}
+
+//#endregion
+//#region src/kernel.ts
+var Kernel = class Kernel {
+	singletons = /* @__PURE__ */ new Map();
+	invokeCache = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	parent;
+	root;
+	constructor(opts = {}) {
+		this.root = opts.parent?.root ?? this;
+		this.parent = opts.parent;
+	}
+	fork() {
+		return new Kernel({ parent: this });
+	}
+	getBinding(key) {
+		return this.bindings.get(key) ?? this.parent?.getBinding(key);
+	}
+	bind(key, impl, scope = "transient") {
+		this.singletons.delete(key);
+		this.bindings.set(key, {
+			impl,
+			scope
+		});
+	}
+	resolve(key, scope) {
+		const binding = this.getBinding(key);
+		const impl = binding?.impl ?? key;
+		const requestedScope = binding?.scope ?? scope ?? impl.scope;
+		if (requestedScope === "singleton") {
+			if (this.root.singletons.has(key)) return this.root.singletons.get(key);
+			const created = this.instantiate(impl);
+			this.root.singletons.set(key, created);
+			return created;
+		}
+		if (requestedScope === "invoke" && !!this.parent) {
+			if (this.invokeCache.has(key)) return this.invokeCache.get(key);
+			const created = this.instantiate(impl);
+			this.invokeCache.set(key, created);
+			return created;
+		}
+		return this.instantiate(impl);
+	}
+	scoped() {
+		return this.fork();
+	}
+	create(cls) {
+		return this.instantiate(cls);
+	}
+	instantiate(cls) {
+		const instance = new cls();
+		this.injectInto(instance);
+		return instance;
+	}
+	injectInto(instance) {
+		const obj = instance;
+		Object.entries(obj).map(([key, value]) => {
+			const injectionPoint = getInjectionPoint(value);
+			if (!injectionPoint) return null;
+			return [key, injectionPoint];
+		}).filter((entry) => entry !== null).forEach(([key, injectionPoint]) => {
+			obj[key] = this.resolve(injectionPoint.token, injectionPoint.scope);
+		});
+	}
+};
+
+//#endregion
+//#region src/kernel-als.ts
+const als = new AsyncLocalStorage();
+function runWithKernel(scopedKernel, fn) {
+	return als.run(scopedKernel, fn);
+}
+function getAlsKernel() {
+	return als.getStore() ?? null;
+}
+
+//#endregion
+//#region src/kernel-current.ts
+let currentKernelFn = null;
+function setCurrentKernelFn(fnKernel) {
+	currentKernelFn = fnKernel;
+}
+function getCurrentKernelFromFn() {
+	return currentKernelFn?.();
+}
+
+//#endregion
+//#region src/kernel-global.ts
+let globalKernel = null;
+function setGlobalKernel(kernel) {
+	globalKernel = kernel;
+}
+function getGlobalKernel() {
+	return globalKernel;
+}
+
+//#endregion
+//#region src/kernel-invoke.ts
+function getInvokeKernel() {
+	return getCurrentKernelFromFn() ?? getAlsKernel() ?? getGlobalKernel()?.scoped() ?? new Kernel();
+}
+
+//#endregion
+//#region src/memo.ts
+function Memoizable(Base) {
+	class MemoizableBase extends Base {
+		memo(fn) {
+			const cache = /* @__PURE__ */ new Map();
+			const keyOf = (args) => objectHash(args);
+			const memoized = ((...args) => {
+				const key = keyOf(args);
+				const hit = cache.get(key);
+				if (hit !== void 0) return hit;
+				const value = fn.apply(this, args);
+				if (typeof value.then === "function") value.catch(() => {
+					cache.delete(key);
+				});
+				cache.set(key, value);
+				return value;
+			});
+			memoized.memoized = memoized;
+			memoized.fresh = ((...args) => {
+				return fn.apply(this, args);
+			});
+			memoized.preload = ((...args) => {
+				return memoized(...args);
+			});
+			memoized.prime = ((...args) => {
+				const key = keyOf(args);
+				return { value: (value) => {
+					if (typeof value.then === "function") value.catch(() => {
+						cache.delete(key);
+					});
+					cache.set(key, value);
+				} };
+			});
+			memoized.bust = (...args) => {
+				cache.delete(keyOf(args));
+			};
+			memoized.bustAll = () => {
+				cache.clear();
+			};
+			return memoized;
+		}
+	}
+	return MemoizableBase;
+}
+
+//#endregion
+//#region src/modules.ts
+const BRAND = Symbol("_capsel_brand");
+var ClassBrand = class {
+	constructor(moduleName, layerName) {
+		this.moduleName = moduleName;
+		this.layerName = layerName;
+	}
+};
+function createModule(moduleName) {
+	function inject(key, scope) {
+		if (key[BRAND].moduleName !== moduleName && key[BRAND].layerName !== "facade") throw new Error(`Cross-module ${key[BRAND].layerName} dependency is not allowed. Use a Facade. (Tried to inject a ${key[BRAND].layerName} from ${key[BRAND].moduleName} into ${moduleName})`);
+		return tokenizedDependency(key, scope ?? key.scope);
+	}
+	class BaseClass {
+		static InvokeScope = "invoke";
+		static TransientScope = "transient";
+		static SingletonScope = "singleton";
+		inject = inject.bind(this);
+	}
+	class Facade extends BaseClass {
+		static [BRAND] = new ClassBrand(moduleName, "facade");
+		static scope = "transient";
+	}
+	class Service extends BaseClass {
+		static [BRAND] = new ClassBrand(moduleName, "service");
+		static scope = "invoke";
+	}
+	class Repo extends Memoizable(BaseClass) {
+		static [BRAND] = new ClassBrand(moduleName, "repo");
+		static scope = "invoke";
+	}
+	class Action extends BaseClass {
+		static [BRAND] = new ClassBrand(moduleName, "action");
+		static scope = "transient";
+		static invoke(...args) {
+			return getInvokeKernel().create(this).handle(...args);
+		}
+		static withKernel(kernel) {
+			const ActionClass = this;
+			return { invoke(...args) {
+				return kernel.scoped().create(ActionClass).handle(...args);
+			} };
+		}
+	}
+	class Singleton extends BaseClass {
+		static [BRAND] = new ClassBrand(moduleName, "other");
+		static scope = "singleton";
+	}
+	class Class extends BaseClass {
+		static [BRAND] = new ClassBrand(moduleName, "other");
+		static scope = "transient";
+	}
+	return {
+		Facade,
+		Service,
+		Repo,
+		Action,
+		Singleton,
+		Class
+	};
+}
+
+//#endregion
+export { Kernel, createModule, runWithKernel, setCurrentKernelFn, setGlobalKernel };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "vla",
+  "type": "module",
+  "version": "0.1.1",
+  "description": "Data layer kernel for backend- and fullstack apps",
+  "author": "Timo Mämecke <hello@timo.wtf>",
+  "license": "MIT",
+  "homepage": "https://github.com/timomeh/capsel#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/timomeh/capsel.git"
+  },
+  "bugs": {
+    "url": "https://github.com/timomeh/capsel/issues"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.10",
+    "@types/node": "^25.0.3",
+    "@types/object-hash": "^3.0.6",
+    "bumpp": "^10.3.2",
+    "tsdown": "^0.18.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "object-hash": "^3.0.0"
+  }
+}