@junejs/db 0.0.33-dev.0 → 0.0.33-dev.2

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { RequestScope, blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale } from "./scope.js";
+export { type RequestScope, blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale } from "./scope.js";
+export { blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale };

package/dist/scope.d.ts

@@ -0,0 +1,20 @@
+import { JuneBlob, JuneDb, JuneKv, Resources } from "@junejs/core/resources";
+//#region src/scope.d.ts
+type RequestScope = {
+  resources: Resources;
+  locals?: Map<symbol, unknown>;
+  locale?: string;
+  services?: unknown;
+};
+declare function ensureScope(): Promise<void>;
+declare function runInScope<T>(scope: RequestScope, fn: () => T): T;
+declare function requestLocal<T>(key: symbol, make: () => T): T;
+declare function setRequestLocale(locale: string): void;
+declare function currentLocale(): string | undefined;
+declare function currentServices<T = unknown>(): T | undefined;
+declare function registerSqlTagger(tag: (sql: string) => void): void;
+declare const db: JuneDb;
+declare const kv: JuneKv;
+declare const blob: JuneBlob;
+//#endregion
+export { RequestScope, blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale };

package/dist/scope.js

@@ -0,0 +1,62 @@
+//#region src/scope.ts
+let als = null;
+let ensuring = null;
+async function ensureScope() {
+	if (als) return;
+	ensuring ??= (async () => {
+		try {
+			als = new (await (import("node:async_hooks"))).AsyncLocalStorage();
+		} catch {}
+	})();
+	await ensuring;
+}
+function runInScope(scope, fn) {
+	return als ? als.run(scope, fn) : fn();
+}
+function requestLocal(key, make) {
+	const store = als?.getStore();
+	if (!store) throw new Error("June: request-scoped state was used outside a request scope. It is only available while a request is being handled (a route loader/view or an action).");
+	const locals = store.locals ??= /* @__PURE__ */ new Map();
+	if (!locals.has(key)) locals.set(key, make());
+	return locals.get(key);
+}
+function setRequestLocale(locale) {
+	const store = als?.getStore();
+	if (store) store.locale = locale;
+}
+function currentLocale() {
+	return als?.getStore()?.locale;
+}
+function currentServices() {
+	return als?.getStore()?.services ?? void 0;
+}
+function pick(name) {
+	const store = als?.getStore();
+	if (!store) throw new Error(`June: \`${name}\` was used outside a request scope. Resources are only available while a request is being handled (a route loader/view or an action).`);
+	const resource = store.resources[name];
+	if (!resource) throw new Error(`June: no \`${name}\` resource is declared. Add \`resources: { ${name}: … }\` to june.config.ts (e.g. \`db: sqlite()\`).`);
+	return resource;
+}
+function ambient(name) {
+	return new Proxy({}, { get(_t, prop) {
+		const resource = pick(name);
+		const value = resource[prop];
+		return typeof value === "function" ? value.bind(resource) : value;
+	} });
+}
+let sqlTagger = null;
+function registerSqlTagger(tag) {
+	sqlTagger = tag;
+}
+const db = new Proxy({}, { get(_t, prop) {
+	const handle = pick("db");
+	const value = handle[prop];
+	if (typeof value !== "function") return value;
+	const fn = value.bind(handle);
+	if (sqlTagger && (prop === "query" || prop === "get" || prop === "run")) return (sql, params) => (sqlTagger(sql), fn(sql, params));
+	return fn;
+} });
+const kv = ambient("kv");
+const blob = ambient("blob");
+//#endregion
+export { blob, currentLocale, currentServices, db, ensureScope, kv, registerSqlTagger, requestLocal, runInScope, setRequestLocale };

package/package.json

@@ -1,22 +1,29 @@
 {
   "name": "@junejs/db",
-  "version": "0.0.33-dev.0",
+  "version": "0.0.33-dev.2",
   "description": "June — the agent-native React framework. Ambient data resources (db/kv/blob).",
   "type": "module",
   "license": "MIT",
   "homepage": "https://june.build",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "source": "./src/index.ts",
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "scripts": {
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.1.0-dev.0"
+    "@junejs/core": ">=0.1.0-dev.4"
   },
   "repository": {
     "type": "git",

package/src/index.ts

@@ -12,6 +12,7 @@ export {
   requestLocal,
   setRequestLocale,
   currentLocale,
+  currentServices,
   registerSqlTagger,
   type RequestScope,
 } from "./scope";

package/src/scope.ts

@@ -33,6 +33,15 @@ export type RequestScope = {
   // opt-in layer (e.g. @junejs/i18n's ambient `t`) reads it WITHOUT the core
   // pipeline depending on that layer. Undefined when no i18n is configured.
   locale?: string;
+  // App-defined services bag, seeded by the host at each ISOLATE ENTRY from that
+  // isolate's env — the Worker pipeline from the worker env, a Durable Object from
+  // its own env (env only exists inside an invocation on workerd, never at module
+  // top-level). This is the seam for resources June does NOT model (Vectorize,
+  // Workers AI, an app ledger, a signing secret): the app builds it where env lives
+  // and reads it ambiently via currentServices(), so a tool needs neither a
+  // module-global setter nor `env` on ctx. Opaque here on purpose — @junejs/db
+  // never names the app's service shape; the app supplies the type at the read.
+  services?: unknown;
 };
 
 // The minimal slice of AsyncLocalStorage we use — kept structural so this module
@@ -100,6 +109,17 @@ export function currentLocale(): string | undefined {
   return als?.getStore()?.locale;
 }
 
+// The current isolate's app-defined services bag (see RequestScope.services), or
+// undefined outside a scope / when none was seeded. Soft (returns undefined) rather
+// than throwing, because services are optional and app-defined: the app wraps this
+// in its OWN typed accessor that throws when a specific service it needs is missing.
+// @junejs/db stays generic — it carries the bag, never inspects it. A nullish bag
+// (unset OR explicitly `null`) normalizes to `undefined` so the `T | undefined`
+// return type is sound — a caller guarding only `undefined` can't be handed a null.
+export function currentServices<T = unknown>(): T | undefined {
+  return (als?.getStore()?.services ?? undefined) as T | undefined;
+}
+
 function pick<K extends keyof Resources>(name: K): NonNullable<Resources[K]> {
   const store = als?.getStore();
   if (!store) {