@auersperg/flare 0.0.0-stage → 0.3.2

package/dist/sdk/server.d.ts

@@ -0,0 +1,146 @@
+export { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { Validator, Schema } from "./schema.js";
+import type { ReadDatabase, WriteDatabase } from "./database.js";
+export { defineSchema, defineTable, schemaContract } from "./schema.js";
+export type { Validator, Schema, Doc, Value, Input, SchemaContract, } from "./schema.js";
+export type { ReadDatabase, WriteDatabase, Page } from "./database.js";
+import { type Auth, type FunctionKind, type FunctionRef, type Json, type Manifest } from "./protocol.js";
+export interface QueryContext<S extends Schema = Schema> {
+    readonly db: ReadDatabase<S>;
+    readonly auth: Auth | null;
+}
+export interface MutationContext<S extends Schema = Schema> {
+    readonly db: WriteDatabase<S>;
+    readonly auth: Auth | null;
+    readonly jobs: {
+        cancel(id: string): Promise<boolean>;
+        schedule(path: string, args: Json, options?: {
+            delaySeconds?: number;
+        }): Promise<string>;
+    };
+}
+export interface ActionContext {
+    readonly auth: Auth | null;
+    runQuery<I, O>(ref: FunctionRef<I, O>, args: I): Promise<O>;
+    runMutation<I, O>(ref: FunctionRef<I, O>, args: I): Promise<O>;
+    readonly schedules: {
+        set(input: {
+            name: string;
+            path: string;
+            cron: string;
+            args: Json;
+        }): Promise<{
+            id: string;
+        }>;
+        cancel(name: string): Promise<boolean>;
+        list(): Promise<{
+            name: string;
+            path: string;
+            cron: string;
+            enabled: boolean;
+        }[]>;
+    };
+    readonly secrets: {
+        get(name: string): Promise<string>;
+    };
+    readonly files: {
+        upload(body: ReadableStream<Uint8Array>, contentType: string, options: {
+            name: string;
+            size: number;
+        }): Promise<string>;
+        download(id: string): Promise<Response>;
+        generateUploadUrl(input: {
+            name: string;
+            type: string;
+            size: number;
+        }): Promise<{
+            id: string;
+            url: string;
+            expiresAt: number;
+        }>;
+        getDownloadUrl(id: string): Promise<{
+            url: string;
+            expiresAt: number;
+        }>;
+        delete(id: string): Promise<{
+            deleted: boolean;
+        }>;
+        list(input?: {
+            cursor?: string | null;
+            limit?: number;
+        }): Promise<{
+            page: {
+                id: string;
+                name: string;
+                type: string;
+                size: number;
+                state: string;
+                createdAt: number;
+            }[];
+            continueCursor: string | null;
+            isDone: boolean;
+        }>;
+    };
+}
+type Context<K extends FunctionKind, S extends Schema = Schema> = K extends "action" ? ActionContext : K extends "mutation" ? MutationContext<S> : QueryContext<S>;
+export interface Definition<K extends FunctionKind = FunctionKind, I = any, O = any, S extends Schema = Schema> {
+    readonly kind: K;
+    readonly input: Validator<any, I>;
+    readonly output: Validator<O, any>;
+    readonly auth: "required" | "public" | "internal";
+    readonly handler: (ctx: Context<K, S>, args: I) => O | Promise<O>;
+}
+export declare const query: <IV extends Validator, OV extends Validator>(options: {
+    input: IV;
+    output: OV;
+    auth?: "required" | "public" | "internal";
+    handler: (ctx: QueryContext<Schema>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+}) => Definition<"query", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
+export declare const mutation: <IV extends Validator, OV extends Validator>(options: {
+    input: IV;
+    output: OV;
+    auth?: "required" | "public" | "internal";
+    handler: (ctx: MutationContext<Schema>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+}) => Definition<"mutation", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
+export declare const action: <IV extends Validator, OV extends Validator>(options: {
+    input: IV;
+    output: OV;
+    auth?: "required" | "public" | "internal";
+    handler: (ctx: ActionContext, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+}) => Definition<"action", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
+export declare function createFunctions<S extends Schema>(): {
+    query: <IV extends Validator, OV extends Validator>(options: {
+        input: IV;
+        output: OV;
+        auth?: "required" | "public" | "internal";
+        handler: (ctx: QueryContext<S>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+    }) => Definition<"query", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, S>;
+    mutation: <IV extends Validator, OV extends Validator>(options: {
+        input: IV;
+        output: OV;
+        auth?: "required" | "public" | "internal";
+        handler: (ctx: MutationContext<S>, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+    }) => Definition<"mutation", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, S>;
+    action: <IV extends Validator, OV extends Validator>(options: {
+        input: IV;
+        output: OV;
+        auth?: "required" | "public" | "internal";
+        handler: (ctx: ActionContext, args: StandardSchemaV1.InferOutput<IV>) => StandardSchemaV1.InferInput<OV> | Promise<StandardSchemaV1.InferInput<OV>>;
+    }) => Definition<"action", StandardSchemaV1.InferOutput<IV>, StandardSchemaV1.InferInput<OV>, Schema>;
+};
+export interface FunctionTree {
+    [key: string]: Definition<any, any, any, any> | FunctionTree;
+}
+export declare function defineApp<const T extends FunctionTree>(options: {
+    functions: T;
+    schema: Schema;
+}): Readonly<{
+    functions: T;
+    schema: Schema;
+}>;
+export declare function flatten(tree: FunctionTree): Record<string, Definition<any, any, any, any>>;
+export declare function manifest(app: {
+    functions: FunctionTree;
+}): Manifest;
+export declare function validate<V extends StandardSchemaV1>(validator: V, value: unknown, output?: boolean): Promise<StandardSchemaV1.InferOutput<V>>;

package/dist/sdk/server.js

@@ -0,0 +1,78 @@
+export { z } from "zod";
+import { schemaContract } from "./schema.js";
+export { defineSchema, defineTable, schemaContract } from "./schema.js";
+import {
+  assertPath,
+  boundedJson,
+  LIMITS,
+  FlareError
+} from "./protocol.js";
+function declare(kind) {
+  return (options) => Object.freeze({ ...options, kind, auth: options.auth ?? "required" });
+}
+export const query = declare("query");
+export const mutation = declare("mutation");
+export const action = declare("action");
+export function createFunctions() {
+  return {
+    query: declare("query"),
+    mutation: declare("mutation"),
+    action
+  };
+}
+export function defineApp(options) {
+  flatten(options.functions);
+  schemaContract(options.schema);
+  return Object.freeze(options);
+}
+export function flatten(tree) {
+  const out = Object.create(null);
+  const ancestors = new Set;
+  function walk(node, prefix, depth) {
+    if (depth > 20 || ancestors.has(node))
+      throw new FlareError("INVALID_CONTRACT", "Invalid function tree");
+    ancestors.add(node);
+    for (const [name, value] of Object.entries(node)) {
+      const path = prefix ? `${prefix}/${name}` : name;
+      assertPath(path);
+      if (value && typeof value === "object" && "handler" in value && typeof value.handler === "function") {
+        const definition = value;
+        if (!["query", "mutation", "action"].includes(definition.kind))
+          throw new FlareError("INVALID_CONTRACT", "Invalid function kind");
+        if (out[path])
+          throw new FlareError("INVALID_CONTRACT", "Duplicate function path");
+        out[path] = definition;
+      } else if (value && typeof value === "object")
+        walk(value, path, depth + 1);
+      else
+        throw new FlareError("INVALID_CONTRACT", "Invalid function definition");
+    }
+    ancestors.delete(node);
+  }
+  walk(tree, "", 0);
+  return out;
+}
+export function manifest(app) {
+  const functions = Object.create(null);
+  for (const [path, fn] of Object.entries(flatten(app.functions))) {
+    const input = fn.input["~standard"].jsonSchema?.input({
+      target: "draft-2020-12"
+    });
+    const output = fn.output["~standard"].jsonSchema?.output({
+      target: "draft-2020-12"
+    });
+    if (!input || !output)
+      throw new FlareError("INVALID_CONTRACT", `${path} requires JSON Schema converters`);
+    functions[path] = { kind: fn.kind, auth: fn.auth, input, output };
+  }
+  boundedJson(functions, 1048576);
+  return { protocol: 1, runtimeAbi: 4, functions };
+}
+export async function validate(validator, value, output = false) {
+  boundedJson(value, output ? LIMITS.outputBytes : LIMITS.inputBytes);
+  const result = await validator["~standard"].validate(value);
+  if (result.issues)
+    throw new FlareError(output ? "INVALID_OUTPUT" : "INVALID_INPUT", output ? "Function returned invalid data" : "Arguments failed validation");
+  boundedJson(result.value, output ? LIMITS.outputBytes : LIMITS.inputBytes);
+  return result.value;
+}

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@auersperg/flare",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.2",
+  "license": "MIT",
+  "type": "module",
+  "description": "Flare client, server declarations and development CLI",
+  "bin": {
+    "flare": "./dist/cli/flare.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/sdk/client.d.ts",
+      "import": "./dist/sdk/client.js"
+    },
+    "./server": {
+      "types": "./dist/sdk/server.d.ts",
+      "import": "./dist/sdk/server.js"
+    },
+    "./react": {
+      "types": "./dist/sdk/react.d.ts",
+      "import": "./dist/sdk/react.js"
+    },
+    "./protocol": {
+      "types": "./dist/sdk/protocol.d.ts",
+      "import": "./dist/sdk/protocol.js"
+    },
+    "./cloudflare": {
+      "types": "./dist/sdk/cloudflare.d.ts",
+      "import": "./dist/sdk/cloudflare.js"
+    }
+  },
+  "dependencies": {
+    "@standard-schema/spec": "1.1.0",
+    "zod": "4.6.5",
+    "json-schema-to-typescript": "16.0.0"
+  },
+  "engines": {
+    "bun": ">=1.4.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/auersperg/flare.git",
+    "directory": "packages/flare"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": ">=19"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "next"
+  },
+  "scripts": {
+    "prepack": "bun run --cwd ../.. verify"
+  }
+}