@concavejs/core 0.0.1-alpha.5 → 0.0.1-alpha.6

package/dist/http/api-router.d.ts

@@ -24,7 +24,7 @@ export interface StorageStoreResult {
 }
 export interface StorageGetResult {
     blob: Blob | null;
-    headers?: HeadersInit;
+    headers?: Record<string, string> | [string, string][] | Headers;
 }
 export interface StorageAdapter {
     store(blob: Blob, request: Request): Promise<StorageStoreResult>;

package/dist/http/api-router.js

@@ -1,6 +1,5 @@
 import { AdminAuthError, assertAdminToken, assertSystemToken, identityFromToken, isAdminToken, isSystemToken, JWTValidationError, SystemAuthError, } from "../auth";
-import { stringToHex, writtenTablesFromRanges } from "../utils";
-import { isValidDocumentId } from "../id-codec";
+import { writtenTablesFromRanges } from "../utils";
 import { InternalFunctionAccessError } from "../errors";
 export function computeCorsHeaders(request) {
     const origin = request.headers.get("Origin");
@@ -154,18 +153,10 @@ export async function handleCoreHttpApiRequest(request, options) {
         }
         if (request.method === "GET" && routeSegments.length === 2) {
             try {
-                let storageId = decodeURIComponent(routeSegments[1]);
-                const originalId = storageId;
-                // If the ID doesn't have a table prefix and isn't a valid Base32 document ID,
-                // it's likely a raw hex storage ID. Prepend the default _storage table prefix.
-                if (!storageId.includes(":") && !isValidDocumentId(storageId)) {
-                    const tableHex = stringToHex("_storage");
-                    storageId = `${tableHex}:${storageId}`;
-                }
+                const storageId = decodeURIComponent(routeSegments[1]);
                 const result = await options.storage.get(storageId, request);
                 const blob = result.blob;
                 if (!blob) {
-                    console.error(`[CoreHttpApi] Storage object not found. ID: ${storageId} (original: ${originalId})`);
                     return {
                         handled: true,
                         response: apply(new Response("Object not found", { status: 404 })),

package/dist/http/http-handler.js

@@ -4,6 +4,7 @@
  * Delegates Convex-style HTTP API routes to shared core logic while
  * wiring runtime execution adapters and docstore.
  */
+import { loadConvexModule } from "../udf";
 import { createClientAdapter } from "../udf/execution-adapter";
 import { UdfKernel } from "../queryengine";
 import { applyCors, computeCorsHeaders, handleCoreHttpApiRequest, resolveAuthContext } from "./index";
@@ -161,10 +162,43 @@ export class HttpHandler {
                 return apply(Response.json({ error: "Invalid function path" }, { status: 400 }));
             }
             const isFunctionHandle = body.path.startsWith("function://");
+            // Normalize slash-separated paths to colon format (e.g. "messages/list" → "messages:list")
+            if (!isFunctionHandle && !body.path.includes(":") && body.path.includes("/")) {
+                const lastSlash = body.path.lastIndexOf("/");
+                body.path = body.path.substring(0, lastSlash) + ":" + body.path.substring(lastSlash + 1);
+            }
             if (!isFunctionHandle && !body.path.includes(":")) {
                 return apply(Response.json({ error: "Invalid function path" }, { status: 400 }));
             }
-            if (body.type !== "query" && body.type !== "mutation" && body.type !== "action") {
+            let udfType;
+            if (body.type === "query" || body.type === "mutation" || body.type === "action") {
+                udfType = body.type;
+            }
+            else if (body.type === undefined || body.type === null) {
+                // Auto-detect type by loading the module and inspecting the export
+                try {
+                    const modulePath = body.path.split(":")[0];
+                    const functionName = body.path.split(":")[1] ?? "default";
+                    const module = await loadConvexModule(modulePath, { hint: "udf" });
+                    const func = module[functionName];
+                    if (!func) {
+                        return apply(Response.json({ error: `Function ${body.path} not found` }, { status: 404 }));
+                    }
+                    if (func.isQuery)
+                        udfType = "query";
+                    else if (func.isMutation)
+                        udfType = "mutation";
+                    else if (func.isAction)
+                        udfType = "action";
+                    else {
+                        return apply(Response.json({ error: `Function ${body.path} is not a valid query, mutation, or action` }, { status: 400 }));
+                    }
+                }
+                catch (error) {
+                    return apply(Response.json({ error: `Could not auto-detect function type: ${error.message}` }, { status: 400 }));
+                }
+            }
+            else {
                 return apply(Response.json({ error: "Invalid function type" }, { status: 400 }));
             }
             try {
@@ -216,10 +250,10 @@ export class HttpHandler {
                     return apply(Response.json({ error: "Invalid args" }, { status: 400 }));
                 }
                 const normalizedArgs = rawArgs ?? {};
-                const result = await this.adapter.executeUdf(body.path, normalizedArgs, body.type, authForExecution, body.componentPath);
+                const result = await this.adapter.executeUdf(body.path, normalizedArgs, udfType, authForExecution, body.componentPath);
                 const writtenTables = writtenTablesFromRanges(result.writtenRanges);
                 // Notify subscriptions for mutations/actions with writes
-                if ((body.type === "mutation" || body.type === "action") && result.writtenRanges?.length) {
+                if ((udfType === "mutation" || udfType === "action") && result.writtenRanges?.length) {
                     await notifyWrites(result.writtenRanges, writtenTables, result.commitTimestamp);
                 }
                 return apply(Response.json({

package/dist/interfaces/execution-context.d.ts

@@ -7,9 +7,10 @@
  * - Distributed Mode: May read from cache or remote, writes go via coordinator
  */
 import type { Transactor, TransactionHandle } from "./transactor";
+import type { UserIdentityAttributes } from "convex/server";
 export interface AuthContext {
     type: "Admin" | "User" | "None";
-    userIdentity?: any;
+    userIdentity?: UserIdentityAttributes;
 }
 export interface ExecutionContext {
     /**

package/dist/kernel/blob-store-gateway.js

@@ -1,5 +1,5 @@
 import { encodeDocumentId, internalIdToHex } from "../id-codec";
-import { parseDeveloperId } from "../queryengine/developer-id";
+import { parseStorageId } from "../queryengine/developer-id";
 import { serializeDeveloperId, stringToHex } from "../utils/utils";
 export class BlobStoreGateway {
     context;
@@ -51,19 +51,19 @@ export class BlobStoreGateway {
         if (!this.storage) {
             return null;
         }
-        const docId = parseDeveloperId(storageId);
+        const docId = parseStorageId(storageId);
         if (!docId) {
-            console.error(`[BlobStoreGateway] Failed to parse storage ID: ${storageId}`);
+            console.debug(`[BlobStoreGateway] Failed to parse storage ID: ${storageId}`);
             return null;
         }
         const docValue = await this.queryRuntime.getVisibleDocumentById(storageId, docId);
         if (!docValue) {
-            console.error(`[BlobStoreGateway] Document not found for storage ID: ${storageId} (table: ${docId.table}, internalId: ${docId.internalId})`);
+            console.debug(`[BlobStoreGateway] Document not found for storage ID: ${storageId} (table: ${docId.table}, internalId: ${docId.internalId}, ts: ${this.context.snapshotTimestamp})`);
             return null;
         }
         const storedBlob = await this.storage.get(docId.internalId);
         if (!storedBlob) {
-            console.error(`[BlobStoreGateway] Blob not found in storage: ${docId.internalId}`);
+            console.debug(`[BlobStoreGateway] Blob not found in storage: ${docId.internalId}`);
             return null;
         }
         return storedBlob instanceof Blob ? storedBlob : new Blob([storedBlob]);
@@ -72,7 +72,7 @@ export class BlobStoreGateway {
         if (!this.storage) {
             return null;
         }
-        const docId = parseDeveloperId(storageId);
+        const docId = parseStorageId(storageId);
         if (!docId) {
             return null;
         }
@@ -85,7 +85,7 @@ export class BlobStoreGateway {
     }
     async delete(storageId) {
         const storage = this.requireStorage();
-        const docId = parseDeveloperId(storageId);
+        const docId = parseStorageId(storageId);
         if (!docId) {
             return;
         }

package/dist/kernel/context-storage.js

@@ -30,18 +30,24 @@ export class ContextStorage {
         }
         return this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     run(value, callback) {
         if (this.als) {
+            // ALS.run handles both sync and async callbacks correctly
             return this.als.run(value, callback);
         }
         this.stack.push(value);
         const result = callback();
         if (result && typeof result.then === "function") {
+            // For async callbacks, clean up the stack when the promise settles.
+            // The cast is safe: the callback returned a Promise<R> which is assignable to R
+            // when the caller expects a Promise return (which is always the case for async callbacks).
             return result.finally(() => {
                 this.stack.pop();
             });
         }
         this.stack.pop();
+        // At this point we've ruled out the Promise branch above, so result is R
         return result;
     }
 }

package/dist/kernel/syscalls/action-syscalls.js

@@ -34,19 +34,17 @@ export class ActionSyscalls {
     async handleRunUdf(args) {
         const target = resolveFunctionTarget(args, this.context.componentPath);
         const udfArguments = normalizeUdfArgsPayload(args.args);
-        const type = args.udfType ?? args.type ?? "mutation";
+        const type = (args.udfType ?? args.type ?? "mutation");
         return await this.invocationManager.execute(target.udfPath, udfArguments, type, target.componentPath);
     }
-    handleCreateFunctionHandle(args) {
+    async handleCreateFunctionHandle(args) {
         const target = resolveFunctionTarget(args, this.context.componentPath);
         return formatFunctionHandle(target.componentPath ?? "", target.udfPath);
     }
     async handleVectorSearch(args) {
-        const { query: vectorQuery } = args;
-        return this.queryRuntime.runVectorSearchAction(vectorQuery);
+        return this.queryRuntime.runVectorSearchAction(args.query);
     }
     async handleSearchAction(args) {
-        const { query: searchQuery } = args;
-        return this.queryRuntime.runSearchAction(searchQuery);
+        return this.queryRuntime.runSearchAction(args.query);
     }
 }

package/dist/kernel/syscalls/database-syscalls.js

@@ -181,7 +181,7 @@ export class DatabaseSyscalls {
             }
         }
         else {
-            for (const [key, val] of Object.entries(value ?? {})) {
+            for (const [key, val] of Object.entries((value ?? {}))) {
                 if (val === "$undefined" || val === undefined) {
                     delete newValue[key];
                 }

package/dist/kernel/syscalls/js-router.d.ts

@@ -1,8 +1,8 @@
-type JsSyscallHandler = (args: Record<string, any>) => Promise<any>;
+type JsSyscallHandler = (args: Record<string, unknown>) => Promise<unknown>;
 export declare class JsSyscallRouter {
     private readonly handlers;
     register(op: string, handler: JsSyscallHandler): void;
     has(op: string): boolean;
-    dispatch(op: string, args: Record<string, any>): Promise<any>;
+    dispatch(op: string, args: Record<string, unknown>): Promise<unknown>;
 }
 export {};

package/dist/kernel/syscalls/kernel-syscalls.d.ts

@@ -5,5 +5,5 @@ export declare class KernelSyscalls {
     constructor(resources: KernelResources);
     syscall(op: string, jsonArgs: string): string;
     asyncSyscall(op: string, jsonArgs: string): Promise<string>;
-    jsSyscall(op: string, args: Record<string, any>): Promise<any>;
+    jsSyscall(op: string, args: Record<string, unknown>): Promise<unknown>;
 }

package/dist/kernel/syscalls/query-syscalls.js

@@ -19,13 +19,13 @@ export class QuerySyscalls {
         return { queryId };
     }
     handleQueryCleanup(args) {
-        const { queryId } = args;
+        const queryId = args.queryId;
         delete this.pendingQueries[queryId];
         delete this.queryResults[queryId];
         return {};
     }
     async handleQueryStreamNext(args) {
-        const { queryId } = args;
+        const queryId = args.queryId;
         if (this.pendingQueries[queryId]) {
             const query = this.pendingQueries[queryId];
             delete this.pendingQueries[queryId];

package/dist/kernel/syscalls/router.d.ts

@@ -1,5 +1,6 @@
-type SyncSyscallHandler = (args: any) => any;
-type AsyncSyscallHandler = (args: any) => Promise<any>;
+type SyscallArgs = Record<string, unknown>;
+type SyncSyscallHandler = (args: SyscallArgs) => unknown;
+type AsyncSyscallHandler = (args: SyscallArgs) => Promise<unknown>;
 export declare class SyscallRouter {
     private readonly syncSyscalls;
     private readonly asyncSyscalls;

package/dist/kernel/syscalls/utils.d.ts

@@ -5,11 +5,11 @@ export interface FunctionTarget {
     componentPath?: string;
 }
 export declare function resolveTableName(docId: InternalDocumentId, tableRegistry: TableRegistry): Promise<string>;
-export declare function normalizeUdfArgsPayload(udfArgs: any): any;
-export declare function resolveFunctionTarget(callArgs: any, currentComponentPath: string): FunctionTarget;
+export declare function normalizeUdfArgsPayload(udfArgs: unknown): unknown;
+export declare function resolveFunctionTarget(callArgs: Record<string, unknown>, currentComponentPath: string): FunctionTarget;
 export declare function parseFunctionHandleTarget(handle: string): FunctionTarget;
 export declare function parseReferenceAddress(reference: string, currentComponentPath: string): FunctionTarget;
 export declare function joinComponentScope(base: string, child: string): string;
 export declare function normalizeComponentPathValue(path?: string | null): string | undefined;
 export declare function formatFunctionHandle(componentPath: string | undefined, udfPath: string): string;
-export declare function evaluatePatchValue(value: any): any;
+export declare function evaluatePatchValue(value: unknown): unknown;

package/dist/kernel/syscalls/utils.js

@@ -37,8 +37,9 @@ export function resolveFunctionTarget(callArgs, currentComponentPath) {
         return parseFunctionHandleTarget(callArgs.functionHandle);
     }
     if (callArgs && typeof callArgs.functionHandle === "object" && callArgs.functionHandle !== null) {
-        if (typeof callArgs.functionHandle.handle === "string") {
-            return parseFunctionHandleTarget(callArgs.functionHandle.handle);
+        const handle = callArgs.functionHandle;
+        if (typeof handle.handle === "string") {
+            return parseFunctionHandleTarget(handle.handle);
         }
     }
     if (callArgs && typeof callArgs.reference === "string") {

package/dist/queryengine/developer-id.d.ts

@@ -14,6 +14,14 @@ import type { InternalDocumentId } from "../docstore/interface";
  * @returns The parsed InternalDocumentId or null if invalid
  */
 export declare function parseDeveloperId(developerId: string): InternalDocumentId | null;
+/**
+ * Parse a storage ID, which may be a full developer ID or a raw internal ID.
+ * If it's a raw internal ID (32-char hex), it defaults to the _storage table.
+ *
+ * @param storageId - The storage ID string
+ * @returns The parsed InternalDocumentId or null if invalid
+ */
+export declare function parseStorageId(storageId: string): InternalDocumentId | null;
 /**
  * Check if an InternalDocumentId uses the component format (has tableNumber).
  */

package/dist/queryengine/developer-id.js

@@ -1,5 +1,5 @@
-import { deserializeDeveloperId } from "../utils/utils";
-import { isValidDocumentId, decodeDocumentId, internalIdToHex } from "../id-codec";
+import { deserializeDeveloperId, stringToHex } from "../utils/utils";
+import { isValidDocumentId, decodeDocumentId, internalIdToHex, INTERNAL_ID_LENGTH } from "../id-codec";
 /**
  * Parse a developer-facing ID string into an InternalDocumentId.
  *
@@ -38,6 +38,27 @@ export function parseDeveloperId(developerId) {
     }
     return { table: parts.table, internalId: parts.internalId };
 }
+/**
+ * Parse a storage ID, which may be a full developer ID or a raw internal ID.
+ * If it's a raw internal ID (32-char hex), it defaults to the _storage table.
+ *
+ * @param storageId - The storage ID string
+ * @returns The parsed InternalDocumentId or null if invalid
+ */
+export function parseStorageId(storageId) {
+    const parsed = parseDeveloperId(storageId);
+    if (parsed) {
+        return parsed;
+    }
+    // If it's a 32-character hex string, it's likely a raw internal ID for storage
+    if (storageId.length === INTERNAL_ID_LENGTH * 2 && /^[0-9a-fA-F]+$/.test(storageId)) {
+        return {
+            table: stringToHex("_storage"),
+            internalId: storageId.toLowerCase(),
+        };
+    }
+    return null;
+}
 /**
  * Check if an InternalDocumentId uses the component format (has tableNumber).
  */

package/dist/router/router.d.ts

@@ -2,14 +2,19 @@
  * Runtime adapter for Concave CLI
  * This is a minimal runtime library used by the generated entry module
  */
+/** Minimal execution context compatible with Cloudflare Workers, Bun, and Node.js */
+export interface RuntimeExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException?(): void;
+}
 export type ConcaveContext = {
     env: any;
     request: Request;
-    ctx: ExecutionContext;
+    ctx: RuntimeExecutionContext;
 };
 export type UdfFunction = (ctx: ConcaveContext, args: unknown) => Promise<unknown>;
 export interface ConcaveRouter {
-    fetch: (request: Request, env: any, ctx: ExecutionContext) => Promise<Response>;
+    fetch: (request: Request, env: any, ctx: RuntimeExecutionContext) => Promise<Response>;
 }
 export interface RouterOptions {
     /**
@@ -17,7 +22,7 @@ export interface RouterOptions {
      * If provided, this handler is called first and can choose to handle the request
      * or delegate to the default router by returning null
      */
-    customFetch?: (request: Request, env: any, ctx: ExecutionContext, registry: Record<string, UdfFunction>) => Promise<Response | null>;
+    customFetch?: (request: Request, env: any, ctx: RuntimeExecutionContext, registry: Record<string, UdfFunction>) => Promise<Response | null>;
     /**
      * Base path for routes (default: "")
      * Example: "/api" would make routes accessible at /api/convex/...

package/dist/runtime/runtime-context.d.ts

@@ -9,7 +9,7 @@ export interface RuntimeContextOptions {
     blobstore?: BlobStore;
     /** Vector storage provider (reserved for future use) */
     vecstore?: unknown;
-    logger?: Pick<typeof console, "info" | "warn" | "error">;
+    logger?: Pick<typeof console, "debug" | "info" | "warn" | "error">;
     moduleLoader?: ModuleLoader | ModuleLoader[];
     moduleLoaders?: ModuleLoader[];
     configureModuleLoaders?: (registry: ModuleRegistry) => void;

package/dist/transactor/occ-transaction.js

@@ -50,9 +50,9 @@ export class OccMutationTransaction {
     }
     getStorageTransaction() {
         const maybeDocStore = this.docstore;
-        const transaction = maybeDocStore.state?.storage?.transaction;
-        if (typeof transaction === "function") {
-            return { transaction };
+        const storage = maybeDocStore.state?.storage;
+        if (storage && typeof storage.transaction === "function") {
+            return { transaction: (fn) => storage.transaction(fn) };
         }
         return undefined;
     }

package/dist/udf/executor/interface.d.ts

@@ -1,5 +1,8 @@
 import type { UdfResult } from "../runtime/udf-setup";
+import type { AuthContext } from "../../sync/protocol-handler";
+import type { UserIdentityAttributes } from "convex/server";
+export type { UdfResult };
 export interface UdfExec {
-    execute(path: string, args: Record<string, any>, type: "query" | "mutation" | "action", auth?: any, componentPath?: string, requestId?: string): Promise<UdfResult>;
-    executeHttp(request: Request, auth?: any, requestId?: string): Promise<Response>;
+    execute(path: string, args: Record<string, unknown>, type: "query" | "mutation" | "action", auth?: AuthContext | UserIdentityAttributes, componentPath?: string, requestId?: string): Promise<UdfResult>;
+    executeHttp(request: Request, auth?: AuthContext | UserIdentityAttributes, requestId?: string): Promise<Response>;
 }

package/dist/udf/runtime/udf-setup.d.ts

@@ -16,11 +16,11 @@ export interface UdfResult {
 export interface UdfRuntimeOps {
     mathRandom: typeof globalThis.Math.random | null;
     dateNow: typeof globalThis.Date.now | null;
-    cryptoRandomUUID: typeof globalThis.crypto.randomUUID | null;
+    cryptoRandomUUID: (() => string) | null;
     cryptoGetRandomValues: typeof globalThis.crypto.getRandomValues | null;
     fetch: typeof globalThis.fetch | null;
-    setInterval: typeof globalThis.setInterval | null;
-    setTimeout: typeof globalThis.setTimeout | null;
+    setInterval: ((callback: (...args: any[]) => void, delay?: number, ...args: any[]) => ReturnType<typeof globalThis.setInterval>) | null;
+    setTimeout: ((callback: (...args: any[]) => void, delay?: number, ...args: any[]) => ReturnType<typeof globalThis.setTimeout>) | null;
     console: typeof console | null;
     convex: ConvexInterface;
 }

package/dist/udf/runtime/udf-setup.js

@@ -68,9 +68,9 @@ function patchGlobals() {
     globalThis.Date.now = udfDateNow;
     globalThis.fetch = udfFetch;
     globalThis.Math.random = udfMathRandom;
-    globalThis.setInterval = udfSetInterval;
-    globalThis.setTimeout = udfSetTimeout;
     const globalAny = globalThis;
+    globalAny.setInterval = udfSetInterval;
+    globalAny.setTimeout = udfSetTimeout;
     globalAny.crypto.randomUUID = udfCryptoRandomUUID;
     globalAny.crypto.getRandomValues = udfCryptoGetRandomValues;
     globalAny.console = udfConsole;
@@ -274,9 +274,11 @@ export function runUdfMutation(docstore, fn, auth, storage, requestId, udfExecut
         // execute within the same transaction scope
         const existingIdGenerator = idGeneratorContext.getStore();
         const idGenerator = existingIdGenerator ?? createDeterministicIdGenerator(seed);
-        return transactionContext
-            .run(parentTransaction, () => idGeneratorContext.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage, seed, parentTransaction, udfExecutor, componentPath)))
-            .catch((error) => {
+        // ContextStorage.run returns R (UdfResult here) but in practice the async
+        // callback produces a Promise<UdfResult>.  We need to attach a .catch for
+        // savepoint rollback, so cast to the runtime-accurate Promise type.
+        const nestedResult = transactionContext.run(parentTransaction, () => idGeneratorContext.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage, seed, parentTransaction, udfExecutor, componentPath)));
+        return nestedResult.catch((error) => {
             parentTransaction.restoreSavepoint(savepoint);
             throw error;
         });

package/dist/utils/long.d.ts

@@ -12,5 +12,5 @@ export declare class Long {
     notEquals(other: Long): boolean;
     comp(other: Long): 1 | 0 | -1;
     lessThanOrEqual(other: Long): boolean;
-    static fromValue(val: any): any;
+    static fromValue(val: any): Long;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@concavejs/core",
-  "version": "0.0.1-alpha.5",
+  "version": "0.0.1-alpha.6",
   "license": "FSL-1.1-Apache-2.0",
   "publishConfig": {
     "access": "public"