talizen 0.2.3 → 0.2.4

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,42 @@ 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" });
+```
+
 ## 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.
 
 ## 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,26 @@
+import { type TalizenRequestOptions } from "./core.js";
+export interface FuncLogEntry {
+    level: string;
+    text: string;
+}
+export interface FuncRunResponse<T = unknown> {
+    ok: boolean;
+    result?: T;
+    logs?: FuncLogEntry[];
+    error?: string;
+}
+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,69 @@
+import { requestJson, } from "./core.js";
+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,7 +1,9 @@
 export * from "./core.js";
+export * from "./auth.js";
 export * from "./cms.js";
 export * from "./captcha-ui.js";
 export * from "./form.js";
+export * from "./func.js";
 export * from "./i18n.js";
 type OneOrMany<T> = T | Array<T>;
 export interface MetadataTitle {

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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"