@zaflun/lumio-sdk 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,138 @@
+interface Validator {
+    type: string;
+    isOptional: boolean;
+    optional(): Validator;
+    items?: Validator;
+    shape?: Record<string, Validator>;
+}
+declare const v: {
+    string(): Validator;
+    number(): Validator;
+    boolean(): Validator;
+    array(items: Validator): Validator;
+    object(shape: Record<string, Validator>): Validator;
+};
+
+interface TableDefinition {
+    columns: Record<string, Validator>;
+    storageScope: string;
+    storage(scope: string): TableDefinition;
+}
+interface SchemaDefinition {
+    tables: Record<string, TableDefinition>;
+}
+declare function defineTable(columns: Record<string, Validator>): TableDefinition;
+declare function defineSchema(tables: Record<string, TableDefinition>): SchemaDefinition;
+
+interface QueryRowsDefinition {
+    __type: "queryRows";
+    table: string;
+}
+declare function queryRows(table: string): QueryRowsDefinition;
+
+interface InsertRowDefinition {
+    __type: "insertRow";
+    table: string;
+    values: Record<string, unknown>;
+    editorOnly: boolean;
+}
+interface InsertRowOptions {
+    editorOnly?: boolean;
+}
+declare function insertRow(table: string, values: Record<string, unknown>, opts?: InsertRowOptions): InsertRowDefinition;
+
+interface PatchRowDefinition {
+    __type: "patchRow";
+    table: string;
+    rowId: string;
+    values: Record<string, unknown>;
+    editorOnly: boolean;
+}
+interface PatchRowOptions {
+    editorOnly?: boolean;
+}
+declare function patchRow(table: string, rowId: string, values: Record<string, unknown>, opts?: PatchRowOptions): PatchRowDefinition;
+
+interface DeleteRowDefinition {
+    __type: "deleteRow";
+    table: string;
+    rowId: string;
+    editorOnly: boolean;
+}
+interface DeleteRowOptions {
+    editorOnly?: boolean;
+}
+declare function deleteRow(table: string, rowId: string, opts?: DeleteRowOptions): DeleteRowDefinition;
+
+interface HandlerContext {
+    db: {
+        get: (table: string, id: string) => Promise<Record<string, unknown> | null>;
+        insert: (table: string, values: Record<string, unknown>) => Promise<string>;
+        patch: (table: string, id: string, values: Record<string, unknown>) => Promise<void>;
+        delete: (table: string, id: string) => Promise<void>;
+    };
+    fetch: (url: string, opts?: RequestInit) => Promise<Response>;
+    auth: {
+        userId: string | null;
+        accountId: string | null;
+    };
+    secrets: {
+        get: (name: string) => Promise<string | null>;
+    };
+}
+interface HandlerConfig {
+    args: Record<string, Validator>;
+    handler: (ctx: HandlerContext, args: Record<string, unknown>) => Promise<unknown>;
+}
+interface QueryDefinition {
+    __type: "query";
+    args: Record<string, Validator>;
+    handler: HandlerConfig["handler"];
+}
+interface MutationDefinition {
+    __type: "mutation";
+    args: Record<string, Validator>;
+    handler: HandlerConfig["handler"];
+}
+interface ActionDefinition {
+    __type: "action";
+    args: Record<string, Validator>;
+    handler: HandlerConfig["handler"];
+}
+declare function query(config: HandlerConfig): QueryDefinition;
+declare function mutation(config: HandlerConfig): MutationDefinition;
+declare function action(config: HandlerConfig): ActionDefinition;
+
+interface FetchActionDefinition {
+    __type: "fetchAction";
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+interface FetchActionOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+declare function fetchAction(url: string, opts?: FetchActionOptions): FetchActionDefinition;
+
+declare function arg(name: string): {
+    __expr: "arg";
+    name: string;
+};
+declare function identity(): {
+    __expr: "identity";
+};
+declare function secret(name: string): {
+    __expr: "secret";
+    name: string;
+};
+declare function filter(field: string, op: string, value: unknown): {
+    __expr: "filter";
+    field: string;
+    op: string;
+    value: unknown;
+};
+
+export { type ActionDefinition, type DeleteRowDefinition, type DeleteRowOptions, type FetchActionDefinition, type FetchActionOptions, type HandlerConfig, type HandlerContext, type InsertRowDefinition, type InsertRowOptions, type MutationDefinition, type PatchRowDefinition, type PatchRowOptions, type QueryDefinition, type QueryRowsDefinition, type SchemaDefinition, type TableDefinition, type Validator, action, arg, defineSchema, defineTable, deleteRow, fetchAction, filter, identity, insertRow, mutation, patchRow, query, queryRows, secret, v };

package/dist/server.js

@@ -0,0 +1,131 @@
+// src/server/schema.ts
+function defineTable(columns) {
+  const table = {
+    columns,
+    storageScope: "instance",
+    storage(scope) {
+      return { ...this, storageScope: scope };
+    }
+  };
+  return table;
+}
+function defineSchema(tables) {
+  return { tables };
+}
+
+// src/server/validators.ts
+function createValidator(type) {
+  return {
+    type,
+    isOptional: false,
+    optional() {
+      return { ...this, isOptional: true };
+    }
+  };
+}
+var v = {
+  string() {
+    return createValidator("string");
+  },
+  number() {
+    return createValidator("number");
+  },
+  boolean() {
+    return createValidator("boolean");
+  },
+  array(items) {
+    return { ...createValidator("array"), items };
+  },
+  object(shape) {
+    return { ...createValidator("object"), shape };
+  }
+};
+
+// src/server/queryRows.ts
+function queryRows(table) {
+  return { __type: "queryRows", table };
+}
+
+// src/server/insertRow.ts
+function insertRow(table, values, opts) {
+  return {
+    __type: "insertRow",
+    table,
+    values,
+    editorOnly: opts?.editorOnly ?? false
+  };
+}
+
+// src/server/patchRow.ts
+function patchRow(table, rowId, values, opts) {
+  return {
+    __type: "patchRow",
+    table,
+    rowId,
+    values,
+    editorOnly: opts?.editorOnly ?? false
+  };
+}
+
+// src/server/deleteRow.ts
+function deleteRow(table, rowId, opts) {
+  return {
+    __type: "deleteRow",
+    table,
+    rowId,
+    editorOnly: opts?.editorOnly ?? false
+  };
+}
+
+// src/server/handlers.ts
+function query(config) {
+  return { __type: "query", args: config.args, handler: config.handler };
+}
+function mutation(config) {
+  return { __type: "mutation", args: config.args, handler: config.handler };
+}
+function action(config) {
+  return { __type: "action", args: config.args, handler: config.handler };
+}
+
+// src/server/fetchAction.ts
+function fetchAction(url, opts) {
+  return {
+    __type: "fetchAction",
+    url,
+    method: opts?.method ?? "GET",
+    headers: opts?.headers,
+    body: opts?.body
+  };
+}
+
+// src/server/expressions.ts
+function arg(name) {
+  return { __expr: "arg", name };
+}
+function identity() {
+  return { __expr: "identity" };
+}
+function secret(name) {
+  return { __expr: "secret", name };
+}
+function filter(field, op, value) {
+  return { __expr: "filter", field, op, value };
+}
+export {
+  action,
+  arg,
+  defineSchema,
+  defineTable,
+  deleteRow,
+  fetchAction,
+  filter,
+  identity,
+  insertRow,
+  mutation,
+  patchRow,
+  query,
+  queryRows,
+  secret,
+  v
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@zaflun/lumio-sdk",
+  "version": "0.1.0",
+  "description": "Lumio Extension SDK — React components, hooks, and server utilities for building Lumio extensions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server.js",
+      "types": "./dist/server.d.ts"
+    },
+    "./runtime": {
+      "import": "./dist/lumio-runtime.global.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "react-reconciler": "^0.32.0",
+    "@zaflun/lumio-extension-types": "0.1.0",
+    "@zaflun/lumio-protocol": "0.1.1"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.1.0",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@types/react-reconciler": "^0.32.0",
+    "jsdom": "^26.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "zaflun",
+    "email": "developers@zaflun.com",
+    "url": "https://withzaflun.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zaflun/lumio.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://developers.lumio.vision",
+  "bugs": {
+    "url": "https://github.com/zaflun/lumio/issues",
+    "email": "developers@zaflun.com"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/server.ts --format esm --dts --clean && pnpm build:runtime",
+    "build:runtime": "tsup --config tsup.runtime.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}