forgeos 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/forge/compiler/client-sdk/build-manifest.ts

@@ -16,11 +16,17 @@ export interface ClientManifest {
     queries: string;
     commands: string;
     liveQueries: string;
+    externalQueries: string;
+    externalCommands: string;
   };
   react: {
     entrypoint: string;
     hooks: string[];
   };
+  vue: {
+    entrypoint: string;
+    composables: string[];
+  };
   excluded: {
     actions: string[];
     workflows: string[];
@@ -41,6 +47,18 @@ export interface ReactManifest {
   clientSafe: true;
 }
 
+export interface VueManifest {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  entrypoint: string;
+  composables: string[];
+  queries: string[];
+  commands: string[];
+  liveQueries: string[];
+  clientSafe: true;
+}
+
 const SERVER_ADAPTER_SUFFIX = ".server.ts";
 
 function collectServerAdapters(classified: ClassifiedPackage[]): string[] {
@@ -101,6 +119,8 @@ export function buildClientManifest(
       queries: "POST /queries/:name",
       commands: "POST /commands/:name",
       liveQueries: "GET /live/:name",
+      externalQueries: "POST /external/:service/queries/:name",
+      externalCommands: "POST /external/:service/commands/:name",
     },
     react: {
       entrypoint: "src/forge/_generated/react.ts",
@@ -113,6 +133,17 @@ export function buildClientManifest(
         "useLiveQuery",
       ],
     },
+    vue: {
+      entrypoint: "src/forge/_generated/vue.ts",
+      composables: [
+        "provideForge",
+        "useForgeClient",
+        "useForgeAuth",
+        "useForgeQuery",
+        "useForgeCommand",
+        "useForgeLiveQuery",
+      ],
+    },
     excluded: {
       actions,
       workflows,
@@ -149,3 +180,31 @@ export function buildReactManifest(clientManifest: ClientManifest): ReactManifes
     clientSafe: true,
   };
 }
+
+export function buildVueManifest(clientManifest: ClientManifest): VueManifest {
+  const composables = [
+    "provideForge",
+    "useForgeClient",
+    "useForgeAuth",
+    "useForgeQuery",
+    "useForgeCommand",
+    "useForgeLiveQuery",
+  ];
+
+  return {
+    schemaVersion: "1.0.0",
+    generatorVersion: GENERATOR_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        clientInputHash: clientManifest.inputHash,
+        composables,
+      }),
+    ),
+    entrypoint: "src/forge/_generated/vue.ts",
+    composables,
+    queries: clientManifest.queries,
+    commands: clientManifest.commands,
+    liveQueries: clientManifest.liveQueries,
+    clientSafe: true,
+  };
+}

package/src/forge/compiler/client-sdk/render-client.ts

@@ -1,10 +1,15 @@
-import type { ClientManifest, ReactManifest } from "./build-manifest.ts";
+import type { ClientManifest, ReactManifest, VueManifest } from "./build-manifest.ts";
 
 export function renderClientTypesTs(): string {
   return `export type ForgeStaticAuth = {
   userId?: string;
   tenantId?: string;
+  organizationId?: string;
+  organizationMembershipId?: string;
   role?: string;
+  roles?: string[];
+  permissions?: string[];
+  claims?: Record<string, unknown>;
   token?: string;
   getToken?: () => string | Promise<string>;
   headers?: Record<string, string>;
@@ -14,7 +19,12 @@ export function renderClientTypesTs(): string {
 export type ForgeResolvedAuth = {
   userId?: string;
   tenantId?: string;
+  organizationId?: string;
+  organizationMembershipId?: string;
   role?: string;
+  roles?: string[];
+  permissions?: string[];
+  claims?: Record<string, unknown>;
   token?: string;
   getToken?: () => string | Promise<string>;
   headers?: Record<string, string>;
@@ -52,6 +62,22 @@ export class ForgeError extends Error {
 export type QueryName = keyof typeof import("./api.ts").api.queries;
 export type CommandName = keyof typeof import("./api.ts").api.commands;
 export type LiveQueryName = keyof typeof import("./api.ts").api.liveQueries;
+export type ExternalCommandName = string;
+export type ExternalQueryName = string;
+export type ExternalRuntimeRefObject = {
+  service: string;
+  name: string;
+  kind?: "command" | "query";
+  language?: string;
+  framework?: string;
+  transport?: string;
+};
+export type ExternalCommandRef =
+  | ExternalCommandName
+  | ExternalRuntimeRefObject;
+export type ExternalQueryRef =
+  | ExternalQueryName
+  | ExternalRuntimeRefObject;
 
 export type LiveSnapshot<T> = {
   subscriptionId: string;
@@ -60,6 +86,22 @@ export type LiveSnapshot<T> = {
   traceId?: string;
 };
 
+export type ForgeCommandResult<T = unknown> =
+  | {
+      ok: true;
+      result: T;
+      status: number;
+      traceId?: string;
+      diagnostics?: { code: string; message: string }[];
+    }
+  | {
+      ok: false;
+      error: { code: string; message: string; details?: unknown };
+      status: number;
+      traceId?: string;
+      diagnostics?: { code: string; message: string }[];
+    };
+
 export type LiveQueryOptions = {
   signal?: AbortSignal;
 };
@@ -70,6 +112,9 @@ export type ForgeClient = {
   readonly lastTraceId?: string;
   query<Name extends QueryName>(name: Name, args: unknown): Promise<unknown>;
   command<Name extends CommandName>(name: Name, args: unknown): Promise<unknown>;
+  commandResult<Name extends CommandName>(name: Name, args: unknown): Promise<ForgeCommandResult<unknown>>;
+  externalQuery<Name extends ExternalQueryRef>(name: Name, args: unknown): Promise<unknown>;
+  externalCommand<Name extends ExternalCommandRef>(name: Name, args: unknown): Promise<unknown>;
   liveQuery<Name extends LiveQueryName>(
     name: Name,
     args: unknown,
@@ -85,8 +130,11 @@ export function renderClientTs(): string {
   return `import { api } from "./api.ts";
 import type {
   ForgeAuthProvider,
+  ForgeCommandResult,
   ForgeClient,
   ForgeClientConfig,
+  ExternalCommandRef,
+  ExternalQueryRef,
   LiveQueryOptions,
   LiveSnapshot,
 } from "./clientTypes.ts";
@@ -98,10 +146,16 @@ export type {
   ForgeAuthProvider,
   ForgeClient,
   ForgeClientConfig,
+  ForgeCommandResult,
   ForgeStaticAuth,
   QueryName,
   CommandName,
   LiveQueryName,
+  ExternalCommandName,
+  ExternalQueryName,
+  ExternalRuntimeRefObject,
+  ExternalCommandRef,
+  ExternalQueryRef,
   ForgeResolvedAuth,
   LiveQueryOptions,
   LiveSnapshot,
@@ -134,7 +188,12 @@ async function resolveAuthHeaders(
       typeof value === "string" &&
       key !== "userId" &&
       key !== "tenantId" &&
+      key !== "organizationId" &&
+      key !== "organizationMembershipId" &&
       key !== "role" &&
+      key !== "roles" &&
+      key !== "permissions" &&
+      key !== "claims" &&
       key !== "token"
     ) {
       headers[key] = value;
@@ -147,9 +206,25 @@ async function resolveAuthHeaders(
   if (resolved.tenantId) {
     headers["x-forge-tenant-id"] = resolved.tenantId;
   }
+  if (resolved.organizationId) {
+    headers["x-forge-organization-id"] = resolved.organizationId;
+    headers["x-forge-tenant-id"] ??= resolved.organizationId;
+  }
+  if (resolved.organizationMembershipId) {
+    headers["x-forge-organization-membership-id"] = resolved.organizationMembershipId;
+  }
   if (resolved.role) {
     headers["x-forge-role"] = resolved.role;
   }
+  if (Array.isArray(resolved.roles)) {
+    headers["x-forge-roles"] = JSON.stringify(resolved.roles);
+  }
+  if (Array.isArray(resolved.permissions)) {
+    headers["x-forge-permissions"] = JSON.stringify(resolved.permissions);
+  }
+  if (resolved.claims && typeof resolved.claims === "object") {
+    headers["x-forge-claims"] = JSON.stringify(resolved.claims);
+  }
 
   return headers;
 }
@@ -179,6 +254,16 @@ function parseJsonPayload(body: unknown): {
   };
 }
 
+function normalizeExternalRef(
+  ref: ExternalCommandRef | ExternalQueryRef,
+): { service: string; name: string } {
+  if (typeof ref === "string") {
+    const [service, ...entryParts] = ref.split(".");
+    return { service: service ?? "", name: entryParts.join(".") };
+  }
+  return { service: ref.service, name: ref.name };
+}
+
 class ForgeHttpClient implements ForgeClient {
   lastTraceId?: string;
 
@@ -192,6 +277,18 @@ class ForgeHttpClient implements ForgeClient {
     return this.invoke("commands", name, args);
   }
 
+  commandResult(name: string, args: unknown): Promise<ForgeCommandResult<unknown>> {
+    return this.invokeResult("commands", name, args);
+  }
+
+  externalQuery(name: ExternalQueryRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("queries", name, args);
+  }
+
+  externalCommand(name: ExternalCommandRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("commands", name, args);
+  }
+
   liveQuery(
     name: string,
     args: unknown,
@@ -223,10 +320,117 @@ class ForgeHttpClient implements ForgeClient {
     name: string,
     args: unknown,
   ): Promise<unknown> {
+    const result = await this.invokeResult(kind, name, args);
+    if (!result.ok) {
+      throw new ForgeError(result.error.message, {
+        code: result.error.code,
+        traceId: result.traceId,
+        status: result.status,
+        details: result.error.details ?? result.diagnostics,
+      });
+    }
+    return result.result;
+  }
+
+  private async invokeResult(
+    kind: "queries" | "commands",
+    name: string,
+    args: unknown,
+  ): Promise<ForgeCommandResult<unknown>> {
     const baseUrl = this.config.url.replace(/\\/$/, "");
     const url = \`\${baseUrl}/\${kind}/\${encodeURIComponent(name)}\`;
     const authHeaders = await resolveAuthHeaders(this.config.auth);
 
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders,
+        },
+        body: JSON.stringify({ args }),
+      });
+    } catch (error) {
+      return {
+        ok: false,
+        status: 0,
+        error: {
+          code: "FORGE_NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "network request failed",
+          details: error,
+        },
+      };
+    }
+
+    let body: unknown;
+    try {
+      body = await response.json();
+    } catch {
+      return {
+        ok: false,
+        status: response.status,
+        error: {
+          code: "FORGE_HTTP_ERROR",
+          message: \`HTTP \${response.status}\`,
+        },
+      };
+    }
+
+    const payload = parseJsonPayload(body);
+    this.lastTraceId = payload.traceId;
+
+    if (!response.ok || payload.ok === false) {
+      const diagnostic = payload.diagnostics?.find((entry) => entry.code);
+      const code =
+        payload.error?.code ?? diagnostic?.code ?? "FORGE_REQUEST_FAILED";
+      const message =
+        payload.error?.message ??
+        diagnostic?.message ??
+        \`Request failed with status \${response.status}\`;
+      return {
+        ok: false,
+        status: response.status,
+        traceId: payload.traceId,
+        diagnostics: payload.diagnostics,
+        error: {
+          code,
+          message,
+          details: payload.error?.details ?? payload.diagnostics,
+        },
+      };
+    }
+
+    return {
+      ok: true,
+      result: payload.result,
+      status: response.status,
+      traceId: payload.traceId,
+      diagnostics: payload.diagnostics,
+    };
+  }
+
+  private async invokeExternal(
+    kind: "queries" | "commands",
+    name: ExternalCommandRef | ExternalQueryRef,
+    args: unknown,
+  ): Promise<unknown> {
+    const normalized = normalizeExternalRef(name);
+    const serviceName = normalized.service;
+    const entryName = normalized.name;
+    if (!serviceName || !entryName) {
+      throw new ForgeError(\`External runtime name must be service.entry\`, {
+        code: "FORGE_EXTERNAL_RUNTIME_NOT_FOUND",
+      });
+    }
+    const baseUrl = this.config.url.replace(/\\/$/, "");
+    const url = \`\${baseUrl}/external/\${encodeURIComponent(serviceName)}/\${kind}/\${encodeURIComponent(entryName)}\`;
+    return this.invokeUrl(url, args);
+  }
+
+  private async invokeUrl(url: string, args: unknown): Promise<unknown> {
+    const authHeaders = await resolveAuthHeaders(this.config.auth);
+
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -297,19 +501,24 @@ class ForgeHttpClient implements ForgeClient {
     const reader = response.body.getReader();
     let buffer = "";
 
-    while (!signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf("\\n\\n");
-      while (boundary !== -1) {
-        const frame = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        this.handleSseFrame(frame, onSnapshot, onError);
-        boundary = buffer.indexOf("\\n\\n");
+    try {
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf("\\n\\n");
+        while (boundary !== -1) {
+          const frame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          this.handleSseFrame(frame, onSnapshot, onError);
+          boundary = buffer.indexOf("\\n\\n");
+        }
       }
+    } finally {
+      await reader.cancel().catch(() => undefined);
+      reader.releaseLock();
     }
   }
 
@@ -383,8 +592,11 @@ export type {
   ForgeReactAuthProvider,
   ForgeReactClient,
   ForgeReactError,
+  ForgeCommandCallResult,
   UseCommandOptions,
   UseCommandResult,
+  UseCommandResultHook,
+  UseCommandResultOptions,
   UseLiveQueryOptions,
   UseLiveQueryResult,
   UseQueryOptions,
@@ -398,6 +610,7 @@ export const useForgeClient = forgeReact.useForgeClient;
 export const useAuth = forgeReact.useAuth;
 export const useQuery = forgeReact.useQuery;
 export const useCommand = forgeReact.useCommand;
+export const useCommandResult = forgeReact.useCommandResult;
 export const useLiveQuery = forgeReact.useLiveQuery;
 `;
 }
@@ -410,8 +623,11 @@ export function renderReactDts(): string {
   ForgeReactAuthProvider,
   ForgeReactClient,
   ForgeReactError,
+  ForgeCommandCallResult,
   UseCommandOptions,
   UseCommandResult,
+  UseCommandResultHook,
+  UseCommandResultOptions,
   UseLiveQueryOptions,
   UseLiveQueryResult,
   UseQueryOptions,
@@ -423,6 +639,7 @@ export declare const useForgeClient: import("forge/react").ForgeReactBindings["u
 export declare const useAuth: import("forge/react").ForgeReactBindings["useAuth"];
 export declare const useQuery: import("forge/react").ForgeReactBindings["useQuery"];
 export declare const useCommand: import("forge/react").ForgeReactBindings["useCommand"];
+export declare const useCommandResult: import("forge/react").ForgeReactBindings["useCommandResult"];
 export declare const useLiveQuery: import("forge/react").ForgeReactBindings["useLiveQuery"];
 `;
 }
@@ -430,3 +647,68 @@ export declare const useLiveQuery: import("forge/react").ForgeReactBindings["use
 export function renderReactManifestTs(manifest: ReactManifest): string {
   return `export const reactManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
 }
+
+export function renderVueTs(): string {
+  return `import { createForgeVueBindings } from "forge/vue";
+import { createForgeClient } from "./client.ts";
+
+export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+const forgeVue = createForgeVueBindings(createForgeClient);
+
+export const ForgeVuePlugin = forgeVue.ForgeVuePlugin;
+export const provideForge = forgeVue.provideForge;
+export const useForgeClient = forgeVue.useForgeClient;
+export const useForgeAuth = forgeVue.useForgeAuth;
+export const useForgeQuery = forgeVue.useForgeQuery;
+export const useForgeCommand = forgeVue.useForgeCommand;
+export const useForgeLiveQuery = forgeVue.useForgeLiveQuery;
+`;
+}
+
+export function renderVueDts(): string {
+  return `export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+export declare const ForgeVuePlugin: import("forge/vue").ForgeVueBindings["ForgeVuePlugin"];
+export declare const provideForge: import("forge/vue").ForgeVueBindings["provideForge"];
+export declare const useForgeClient: import("forge/vue").ForgeVueBindings["useForgeClient"];
+export declare const useForgeAuth: import("forge/vue").ForgeVueBindings["useForgeAuth"];
+export declare const useForgeQuery: import("forge/vue").ForgeVueBindings["useForgeQuery"];
+export declare const useForgeCommand: import("forge/vue").ForgeVueBindings["useForgeCommand"];
+export declare const useForgeLiveQuery: import("forge/vue").ForgeVueBindings["useForgeLiveQuery"];
+`;
+}
+
+export function renderVueManifestTs(manifest: VueManifest): string {
+  return `export const vueManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
+}

package/src/forge/compiler/data-graph/parse.ts

@@ -36,7 +36,23 @@ function unwrapStringLiteral(node: SyntaxNode): string | null {
   return null;
 }
 
-function extractFieldsFromObject(objectNode: SyntaxNode): DataField[] {
+function unwrapNullableType(node: SyntaxNode): string | null {
+  if (node.type !== "call_expression") {
+    return null;
+  }
+  const functionNode = node.childForFieldName("function");
+  if (functionNode?.type !== "identifier" || functionNode.text !== "nullable") {
+    return null;
+  }
+  const argsNode = node.childForFieldName("arguments");
+  const firstArg = argsNode?.namedChildren.find((child) =>
+    child.type !== "," && child.type !== "comment" && child.type !== "(" && child.type !== ")"
+  );
+  const inner = firstArg ? unwrapStringLiteral(firstArg) : null;
+  return inner ? `${inner}?` : null;
+}
+
+function extractFieldsFromObject(objectNode: SyntaxNode, options: { skipConfigName?: boolean } = {}): DataField[] {
   const fields: DataField[] = [];
 
   for (const child of objectNode.namedChildren) {
@@ -55,7 +71,7 @@ function extractFieldsFromObject(objectNode: SyntaxNode): DataField[] {
         ? keyNode.text
         : unwrapStringLiteral(keyNode);
 
-    if (!key || key === "name") {
+    if (!key || (options.skipConfigName && key === "name")) {
       continue;
     }
 
@@ -64,7 +80,7 @@ function extractFieldsFromObject(objectNode: SyntaxNode): DataField[] {
       continue;
     }
 
-    const typeValue = unwrapStringLiteral(valueNode);
+    const typeValue = unwrapStringLiteral(valueNode) ?? unwrapNullableType(valueNode);
     if (typeValue !== null) {
       fields.push({ name: key, type: typeValue });
     }
@@ -131,7 +147,7 @@ function parseCallArguments(callNode: SyntaxNode): ParsedDefineTable | null {
 
   if (first.type === "object") {
     const tableName = extractNameFromObject(first);
-    const fields = extractFieldsFromObject(first);
+    const fields = extractFieldsFromObject(first, { skipConfigName: true });
     return { tableName, fields };
   }