@lunora/server 1.0.0-alpha.21 → 1.0.0-alpha.211

package/dist/data-model.mjs

@@ -1 +0,0 @@
-

package/dist/drizzle.mjs

@@ -1 +1 @@
-export * from 'drizzle-orm/sqlite-core';
+export*from"drizzle-orm/sqlite-core";

package/dist/in-process.d.mts

@@ -0,0 +1,101 @@
+import { SqlExec } from '@lunora/shard-engine';
+import { DatabaseWriter, Schema } from "./types.mjs";
+import '@lunora/values';
+/** The kind of a registered Lunora function. */
+type FunctionKind = "action" | "mutation" | "query";
+/**
+ * A caller-supplied identity. `userId` is the subject a handler reads from
+ * `ctx.auth.userId`; every other field is returned from
+ * `ctx.auth.getIdentity()` (mirroring a decoded JWT's claims).
+ */
+interface InProcessIdentity extends Record<string, unknown> {
+  userId?: null | string;
+}
+/** The `userId` + claims a dispatch runs under, after production's normalisation. */
+interface ResolvedIdentity {
+  readonly claims: Record<string, unknown> | null;
+  readonly userId: null | string;
+}
+/**
+ * Reduce a caller-supplied {@link InProcessIdentity} to what production would
+ * actually hand a shard.
+ *
+ * Mirrors `@lunora/runtime`'s `create-worker.ts` identity forwarding: an identity
+ * whose `userId` is not a non-empty string is dropped to anonymous outright, and
+ * the forwarded claims are the identity MINUS `userId` (`null` when nothing is
+ * left), because the shard reads the subject from its own header and surfaces
+ * only the remaining claims through `ctx.auth.getIdentity()`.
+ * @param identity the caller-supplied identity, or `null` for anonymous
+ * @returns the identity production would forward
+ */
+declare const resolveInProcessIdentity: (identity: InProcessIdentity | null) => ResolvedIdentity;
+/** Options accepted by {@link createInProcessRuntime}. */
+interface InProcessRuntimeOptions {
+  /**
+   * Enforce the secure-by-default RLS guard on {@link InProcessRuntime.createWriters}'s
+   * `database` — the same `enforceRls: true` production's generated
+   * `buildCtx` always passes. A no-op unless the schema is `.rls("required")`.
+   * @default true
+   */
+  enforceRls?: boolean;
+  /**
+   * The `ctx.scheduler` the consumer installs, when it installs one. A
+   * scheduler wrapped with `withDeferredSchedules` has the jobs a mutation
+   * schedules held until its COMMIT and dropped on its ROLLBACK, exactly as the
+   * generated shard's `runMutationTransaction` does.
+   */
+  scheduler?: unknown;
+  /** The synchronous SQLite engine the store runs on. */
+  sql: SqlExec;
+}
+/** The engine-bound half of a function dispatch, shared by every identity view. */
+interface InProcessRuntime {
+  /**
+   * The guarded `ctx.db` writer for one identity, plus the trusted, UNGUARDED
+   * writer behind it (`rawDatabase` — what production's admin/migration paths
+   * use). Both carry the per-table facade (`ctx.db.<table>`).
+   */
+  createWriters: (identity: ResolvedIdentity) => {
+    database: DatabaseWriter;
+    rawDatabase: DatabaseWriter;
+  };
+  /** Start a new top-level dispatch with a full resource budget. Call before every query/action entry. */
+  resetHeadroom: () => void;
+  /**
+   * Run `body` as one top-level entry: serialized behind every other entry that
+   * came through here, inside a BEGIN/COMMIT span that rolls back on a throw,
+   * with a fresh resource budget. Every mutation entry must use it; a read that
+   * must not observe another entry's uncommitted writes may use it too.
+   */
+  runInTransaction: <R>(body: () => Promise<R> | R) => Promise<R>;
+}
+/**
+ * Migrate `schema` onto `options.sql` and return the dispatch wiring around it.
+ * @param schema the app schema from `defineSchema`
+ * @param options the engine, plus the RLS and scheduler settings
+ * @returns the writer factory and the mutation transaction runner
+ */
+declare const createInProcessRuntime: (schema: Schema, options: InProcessRuntimeOptions) => InProcessRuntime;
+/**
+ * The kind of a registered function object, or `undefined` for anything else
+ * (an inline callback, a plain value).
+ * @param value the candidate reference
+ * @returns its kind, when it is a registered function
+ */
+declare const registeredFunctionKind: (value: unknown) => FunctionKind | undefined;
+/**
+ * Invoke a registered function's handler, refusing a reference of the wrong
+ * kind and — unless `allowInternal` — an `internal*` function, which is
+ * unreachable from the external RPC boundary in production.
+ * @param expected which kind of function the call site dispatches
+ * @param reference the registered function object
+ * @param reference.handler its handler, invoked with `(context, args)`
+ * @param context the `ctx` to hand the handler
+ * @param args the call's arguments (`{}` when absent)
+ * @param allowInternal whether this is a server-to-server (`ctx.run*`) dispatch
+ * @returns the handler's result
+ */
+declare const runRegisteredFunction: (expected: FunctionKind, reference: {
+  handler: (context: unknown, args: never) => unknown;
+}, context: unknown, args: unknown, allowInternal: boolean) => Promise<unknown>;
+export { type FunctionKind, type InProcessIdentity, type InProcessRuntime, type InProcessRuntimeOptions, type ResolvedIdentity, createInProcessRuntime, registeredFunctionKind, resolveInProcessIdentity, runRegisteredFunction };

package/dist/in-process.d.ts

@@ -0,0 +1,101 @@
+import { SqlExec } from '@lunora/shard-engine';
+import { DatabaseWriter, Schema } from "./types.js";
+import '@lunora/values';
+/** The kind of a registered Lunora function. */
+type FunctionKind = "action" | "mutation" | "query";
+/**
+ * A caller-supplied identity. `userId` is the subject a handler reads from
+ * `ctx.auth.userId`; every other field is returned from
+ * `ctx.auth.getIdentity()` (mirroring a decoded JWT's claims).
+ */
+interface InProcessIdentity extends Record<string, unknown> {
+  userId?: null | string;
+}
+/** The `userId` + claims a dispatch runs under, after production's normalisation. */
+interface ResolvedIdentity {
+  readonly claims: Record<string, unknown> | null;
+  readonly userId: null | string;
+}
+/**
+ * Reduce a caller-supplied {@link InProcessIdentity} to what production would
+ * actually hand a shard.
+ *
+ * Mirrors `@lunora/runtime`'s `create-worker.ts` identity forwarding: an identity
+ * whose `userId` is not a non-empty string is dropped to anonymous outright, and
+ * the forwarded claims are the identity MINUS `userId` (`null` when nothing is
+ * left), because the shard reads the subject from its own header and surfaces
+ * only the remaining claims through `ctx.auth.getIdentity()`.
+ * @param identity the caller-supplied identity, or `null` for anonymous
+ * @returns the identity production would forward
+ */
+declare const resolveInProcessIdentity: (identity: InProcessIdentity | null) => ResolvedIdentity;
+/** Options accepted by {@link createInProcessRuntime}. */
+interface InProcessRuntimeOptions {
+  /**
+   * Enforce the secure-by-default RLS guard on {@link InProcessRuntime.createWriters}'s
+   * `database` — the same `enforceRls: true` production's generated
+   * `buildCtx` always passes. A no-op unless the schema is `.rls("required")`.
+   * @default true
+   */
+  enforceRls?: boolean;
+  /**
+   * The `ctx.scheduler` the consumer installs, when it installs one. A
+   * scheduler wrapped with `withDeferredSchedules` has the jobs a mutation
+   * schedules held until its COMMIT and dropped on its ROLLBACK, exactly as the
+   * generated shard's `runMutationTransaction` does.
+   */
+  scheduler?: unknown;
+  /** The synchronous SQLite engine the store runs on. */
+  sql: SqlExec;
+}
+/** The engine-bound half of a function dispatch, shared by every identity view. */
+interface InProcessRuntime {
+  /**
+   * The guarded `ctx.db` writer for one identity, plus the trusted, UNGUARDED
+   * writer behind it (`rawDatabase` — what production's admin/migration paths
+   * use). Both carry the per-table facade (`ctx.db.<table>`).
+   */
+  createWriters: (identity: ResolvedIdentity) => {
+    database: DatabaseWriter;
+    rawDatabase: DatabaseWriter;
+  };
+  /** Start a new top-level dispatch with a full resource budget. Call before every query/action entry. */
+  resetHeadroom: () => void;
+  /**
+   * Run `body` as one top-level entry: serialized behind every other entry that
+   * came through here, inside a BEGIN/COMMIT span that rolls back on a throw,
+   * with a fresh resource budget. Every mutation entry must use it; a read that
+   * must not observe another entry's uncommitted writes may use it too.
+   */
+  runInTransaction: <R>(body: () => Promise<R> | R) => Promise<R>;
+}
+/**
+ * Migrate `schema` onto `options.sql` and return the dispatch wiring around it.
+ * @param schema the app schema from `defineSchema`
+ * @param options the engine, plus the RLS and scheduler settings
+ * @returns the writer factory and the mutation transaction runner
+ */
+declare const createInProcessRuntime: (schema: Schema, options: InProcessRuntimeOptions) => InProcessRuntime;
+/**
+ * The kind of a registered function object, or `undefined` for anything else
+ * (an inline callback, a plain value).
+ * @param value the candidate reference
+ * @returns its kind, when it is a registered function
+ */
+declare const registeredFunctionKind: (value: unknown) => FunctionKind | undefined;
+/**
+ * Invoke a registered function's handler, refusing a reference of the wrong
+ * kind and — unless `allowInternal` — an `internal*` function, which is
+ * unreachable from the external RPC boundary in production.
+ * @param expected which kind of function the call site dispatches
+ * @param reference the registered function object
+ * @param reference.handler its handler, invoked with `(context, args)`
+ * @param context the `ctx` to hand the handler
+ * @param args the call's arguments (`{}` when absent)
+ * @param allowInternal whether this is a server-to-server (`ctx.run*`) dispatch
+ * @returns the handler's result
+ */
+declare const runRegisteredFunction: (expected: FunctionKind, reference: {
+  handler: (context: unknown, args: never) => unknown;
+}, context: unknown, args: unknown, allowInternal: boolean) => Promise<unknown>;
+export { type FunctionKind, type InProcessIdentity, type InProcessRuntime, type InProcessRuntimeOptions, type ResolvedIdentity, createInProcessRuntime, registeredFunctionKind, resolveInProcessIdentity, runRegisteredFunction };

package/dist/in-process.mjs

@@ -0,0 +1 @@
+import{LunoraError as I}from"@lunora/errors";import{runShardMigrations as R,TransactionHeadroomTracker as h,createShardCtxDb as T,RLS_UNWRAP_SYMBOL as g}from"@lunora/shard-engine";import{beginDeferredSchedules as p}from"./packem_shared/beginDeferredSchedules-C7QLYr6C.mjs";import{bindTableFacade as y}from"./packem_shared/bindOrm-9fbLRbOb.mjs";const k=e=>{if(e===null||typeof e.userId!="string"||e.userId.length===0)return{claims:null,userId:null};const{userId:r,...s}=e;return{claims:Object.keys(s).length>0?s:null,userId:r}};class S extends h{current=new h;reset(){this.current=new h}headroom(){return this.current.headroom()}recordRead(r){this.current.recordRead(r)}recordWrite(r){this.current.recordWrite(r)}}const x=(e,r)=>{const{scheduler:s,sql:a}=r,i=e;R(a,i);const c=new S,m=t=>{const n=t;for(const o of Object.keys(i.tables))n[o]=y(t,o);return t};let u=!1;const w=t=>{const n=T({auth:{identity:t.claims,userId:t.userId},enforceRls:r.enforceRls??!0,headroom:c,inTransaction:()=>u,schema:i,sql:a}),o=n[g]??n;return{database:m(n),rawDatabase:m(o)}},l=t=>{a.exec.call(a,t)};let f=Promise.resolve();return{createWriters:w,resetHeadroom:()=>{c.reset()},runInTransaction:t=>{const n=async()=>{const b=p({scheduler:s});c.reset(),l("BEGIN"),u=!0;try{const d=await t();return l("COMMIT"),u=!1,await b(!0),d}catch(d){u=!1;try{l("ROLLBACK")}catch{}throw await b(!1),d}},o=f.then(n);return f=o.then(()=>{},()=>{}),o}}},v=e=>{if(typeof e!="object"||e===null)return;const{kind:r}=e;if(r==="query"||r==="mutation"||r==="action")return r},A=(e,r,s,a,i)=>{const c=v(r);if(c!==e)throw new I("INTERNAL",`expected a registered ${e}, received a ${c??"non-function"} reference`);if(!i&&r.visibility==="internal")throw new I("INTERNAL",`This ${e} is an internal function — it is unreachable from the external RPC boundary in production. Call it through ctx.run${e.charAt(0).toUpperCase()}${e.slice(1)} from another function instead.`);return Promise.resolve(r.handler(s,a??{}))};export{x as createInProcessRuntime,v as registeredFunctionKind,k as resolveInProcessIdentity,A as runRegisteredFunction};