talizen 0.2.3 → 0.2.5

package/README.md

@@ -3,8 +3,10 @@
 Talizen's frontend SDK package. It provides a small runtime client and shared types for:
 
 - `talizen/core`
+- `talizen/auth`
 - `talizen/cms`
 - `talizen/form`
+- `talizen/func`
 
 The package is designed to hold the platform-level APIs that frontend projects use directly, while project-specific CMS and form schema types can still be generated separately per project.
 
@@ -106,11 +108,63 @@ When a `File` object appears in the payload, `submitForm()` will:
 3. Replace the original `File` value with the returned `file_url`
 4. Submit the final payload to `/form/:key/submit`
 
+### Login users
+
+```ts
+import { currentUser, login, logout, register } from "talizen/auth";
+
+await register({ email: "hi@talizen.com", password: "secret", name: "Alice" });
+await login({ email: "hi@talizen.com", password: "secret" });
+
+const user = await currentUser();
+await logout();
+```
+
+### Invoke a custom function
+
+```ts
+import { invoke } from "talizen/func";
+
+const result = await invoke<{ success: boolean }>("user/auth.login", {
+  email: "hi@talizen.com",
+  password: "secret",
+});
+```
+
+`invoke("<fileKey>.<method>", input)` calls the method exported by the script file. If `.method` is omitted, Talizen calls `main`:
+
+```ts
+await invoke("user/auth", { email: "hi@talizen.com" });
+```
+
+### Write function runtime code
+
+Func code can use TypeScript and import runtime-only helpers from `talizen/func`:
+
+```ts
+import { auth, db, cache } from "talizen/func";
+
+export function create(input: { title: string }) {
+  const user = auth.requireUser();
+  const row = db.insert("book", {
+    title: input.title,
+    user_id: user.id,
+    status: "draft",
+  });
+  cache.set(`book:${row.id}`, row, 60);
+  return { ok: true, id: row.id };
+}
+```
+
+`db`, `cache`, and Func `auth` are injected by the Talizen Func runtime. They are typed in this package for authoring, but they are not browser/Node general-purpose APIs.
+
 ## Package Layout
 
 - `talizen/core`: shared runtime config, request helpers, and base data types.
+- `talizen/auth`: project user register, login, logout, and current user helpers.
 - `talizen/cms`: CMS content types and content query APIs.
 - `talizen/form`: form submission helpers and related types.
+- `talizen/func`: custom function invocation helpers and Func-runtime-only `db`, `cache`, `auth` types.
 
 ## Publish
 

package/auth.d.ts

@@ -0,0 +1,32 @@
+import { type TalizenRequestOptions } from "./core.js";
+export interface AuthUser {
+    id: string;
+    email?: string;
+    phone?: string;
+    name?: string;
+    avatar?: string;
+    status?: string;
+    profile?: unknown;
+    email_verified_at?: string | null;
+    last_login_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface AuthPasswordInput {
+    email: string;
+    password: string;
+}
+export interface AuthRegisterInput extends AuthPasswordInput {
+    phone?: string;
+    name?: string;
+    avatar?: string;
+    profile?: unknown;
+}
+export declare class TalizenAuthError extends Error {
+    constructor(message: string);
+}
+export declare function register(input: AuthRegisterInput, options?: TalizenRequestOptions): Promise<AuthUser>;
+export declare function login(input: AuthPasswordInput, options?: TalizenRequestOptions): Promise<AuthUser>;
+export declare function logout(options?: TalizenRequestOptions): Promise<void>;
+export declare function currentUser(options?: TalizenRequestOptions): Promise<AuthUser | null>;
+export declare function requireUser(options?: TalizenRequestOptions): Promise<AuthUser>;

package/auth.js

@@ -0,0 +1,35 @@
+import { requestJson, } from "./core.js";
+export class TalizenAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TalizenAuthError";
+    }
+}
+export async function register(input, options) {
+    return requestJson("/auth/register", {
+        method: "POST",
+        body: JSON.stringify(input),
+    }, options);
+}
+export async function login(input, options) {
+    return requestJson("/auth/login", {
+        method: "POST",
+        body: JSON.stringify(input),
+    }, options);
+}
+export async function logout(options) {
+    await requestJson("/auth/logout", {
+        method: "POST",
+        body: JSON.stringify({}),
+    }, options);
+}
+export async function currentUser(options) {
+    return requestJson("/auth/me", { method: "GET" }, options);
+}
+export async function requireUser(options) {
+    const user = await currentUser(options);
+    if (!user) {
+        throw new TalizenAuthError("Login required.");
+    }
+    return user;
+}

package/func.d.ts

@@ -0,0 +1,91 @@
+import { type TalizenRequestOptions } from "./core.js";
+import type { AuthUser } from "./auth.js";
+export interface FuncLogEntry {
+    level: string;
+    text: string;
+}
+export interface FuncRunResponse<T = unknown> {
+    ok: boolean;
+    result?: T;
+    logs?: FuncLogEntry[];
+    error?: string;
+}
+export type DbOrderBy = string;
+export interface DbFilterCondition {
+    field_id?: string;
+    fieldId?: string;
+    operator: "equal" | "not_equal" | "in";
+    value?: unknown;
+    values?: unknown[];
+}
+export interface DbFilter {
+    match?: "and" | "or";
+    conditions?: DbFilterCondition[];
+}
+export interface DbQuery {
+    where?: Record<string, unknown>;
+    filter?: DbFilter;
+    limit?: number;
+    offset?: number;
+    order_by?: DbOrderBy;
+    orderBy?: DbOrderBy;
+}
+export type DbRecord<T extends Record<string, unknown> = Record<string, unknown>> = T & {
+    id: string;
+};
+export interface FuncDbRuntime {
+    get<T extends Record<string, unknown> = Record<string, unknown>>(table: string, id: string): DbRecord<T> | null;
+    query<T extends Record<string, unknown> = Record<string, unknown>>(table: string, query?: DbQuery): Array<DbRecord<T>>;
+    insert<T extends Record<string, unknown> = Record<string, unknown>>(table: string, data: T): DbRecord<T>;
+    update<T extends Record<string, unknown> = Record<string, unknown>>(table: string, id: string, data: Partial<T>): {
+        ok?: boolean;
+        updated?: boolean;
+    } | DbRecord<T>;
+    delete(table: string, id: string): {
+        ok?: boolean;
+        deleted?: boolean;
+    };
+}
+export interface FuncAuthRuntime {
+    currentUser(): AuthUser | null;
+    requireUser(): AuthUser;
+}
+export interface CacheSetOptions {
+    ttl?: number;
+    ttlSeconds?: number;
+}
+export interface FuncCacheRuntime {
+    get<T = unknown>(key: string): T | null;
+    set(key: string, value: unknown, ttlSeconds?: number): {
+        ok?: boolean;
+    };
+    set(key: string, value: unknown, options?: CacheSetOptions): {
+        ok?: boolean;
+    };
+    del(key: string): {
+        ok?: boolean;
+        deleted?: boolean;
+    };
+    incr(key: string, delta?: number): number;
+    expire(key: string, ttlSeconds: number): {
+        ok?: boolean;
+    };
+}
+export declare const db: FuncDbRuntime;
+export declare const auth: FuncAuthRuntime;
+export declare const cache: FuncCacheRuntime;
+export declare class TalizenFuncError extends Error {
+    readonly key: string;
+    readonly method: string;
+    readonly logs: FuncLogEntry[];
+    constructor(key: string, method: string, message: string, logs?: FuncLogEntry[]);
+}
+export declare function invoke<T = unknown>(name: string, input?: unknown, options?: TalizenRequestOptions): Promise<T>;
+export interface RunFuncOptions extends TalizenRequestOptions {
+    method?: string;
+}
+export declare function runFunc<T = unknown>(key: string, input?: unknown, options?: RunFuncOptions): Promise<T>;
+export declare function parseInvokeName(name: string): {
+    key: string;
+    method: string;
+};

package/func.js

@@ -0,0 +1,90 @@
+import { requestJson, } from "./core.js";
+function funcRuntimeUnavailable() {
+    throw new Error("talizen/func db/cache/auth are only available inside Talizen Func runtime.");
+}
+export const db = {
+    get: funcRuntimeUnavailable,
+    query: funcRuntimeUnavailable,
+    insert: funcRuntimeUnavailable,
+    update: funcRuntimeUnavailable,
+    delete: funcRuntimeUnavailable,
+};
+export const auth = {
+    currentUser: funcRuntimeUnavailable,
+    requireUser: funcRuntimeUnavailable,
+};
+export const cache = {
+    get: funcRuntimeUnavailable,
+    set: funcRuntimeUnavailable,
+    del: funcRuntimeUnavailable,
+    incr: funcRuntimeUnavailable,
+    expire: funcRuntimeUnavailable,
+};
+export class TalizenFuncError extends Error {
+    key;
+    method;
+    logs;
+    constructor(key, method, message, logs) {
+        super(message);
+        this.name = "TalizenFuncError";
+        this.key = key;
+        this.method = method;
+        this.logs = logs ?? [];
+    }
+}
+export async function invoke(name, input, options) {
+    const target = parseInvokeName(name);
+    return runFunc(target.key, input, {
+        ...options,
+        method: target.method,
+    });
+}
+export async function runFunc(key, input, options) {
+    const normalizedKey = normalizeFuncKey(key);
+    const method = normalizeFuncMethod(options?.method);
+    const response = await requestJson(`/func/${encodeFuncKey(normalizedKey)}${method === "main" ? "" : `.${encodeURIComponent(method)}`}`, {
+        method: "POST",
+        body: JSON.stringify(input ?? {}),
+    }, options);
+    if (!response.ok) {
+        throw new TalizenFuncError(normalizedKey, method, response.error || "Talizen func failed.", response.logs);
+    }
+    return response.result;
+}
+export function parseInvokeName(name) {
+    const normalized = normalizeFuncKey(name);
+    const lastSlash = normalized.lastIndexOf("/");
+    const lastDot = normalized.lastIndexOf(".");
+    if (lastDot <= lastSlash) {
+        return { key: normalized, method: "main" };
+    }
+    const key = normalized.slice(0, lastDot);
+    const method = normalized.slice(lastDot + 1);
+    return {
+        key: normalizeFuncKey(key),
+        method: normalizeFuncMethod(method),
+    };
+}
+function normalizeFuncKey(key) {
+    const normalized = key.trim().replace(/^\/+|\/+$/g, "");
+    if (normalized === "") {
+        throw new Error("Talizen func key is required.");
+    }
+    if (normalized.includes("..") || normalized.includes("\0")) {
+        throw new Error(`Invalid Talizen func key: ${key}`);
+    }
+    return normalized;
+}
+function normalizeFuncMethod(method) {
+    const normalized = (method ?? "main").trim();
+    if (normalized === "") {
+        return "main";
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(normalized)) {
+        throw new Error(`Invalid Talizen func method: ${method}`);
+    }
+    return normalized;
+}
+function encodeFuncKey(key) {
+    return key.split("/").map(encodeURIComponent).join("/");
+}

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./core.js";
+export * from "./auth.js";
 export * from "./cms.js";
 export * from "./captcha-ui.js";
 export * from "./form.js";

package/index.js

@@ -1,4 +1,5 @@
 export * from "./core.js";
+export * from "./auth.js";
 export * from "./cms.js";
 export * from "./captcha-ui.js";
 export * from "./form.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",
@@ -20,6 +20,10 @@
       "types": "./core.d.ts",
       "import": "./core.js"
     },
+    "./auth": {
+      "types": "./auth.d.ts",
+      "import": "./auth.js"
+    },
     "./cms": {
       "types": "./cms.d.ts",
       "import": "./cms.js"
@@ -32,6 +36,10 @@
       "types": "./form.d.ts",
       "import": "./form.js"
     },
+    "./func": {
+      "types": "./func.d.ts",
+      "import": "./func.js"
+    },
     "./i18n": {
       "types": "./i18n.d.ts",
       "import": "./i18n.js"