talizen 0.2.6 → 0.2.8

package/README.md

@@ -112,13 +112,30 @@ When a `File` object appears in the payload, `submitForm()` will:
 ### 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" });
+import {
+  currentUser,
+  listAuthProviders,
+  login,
+  loginWithOAuth,
+  logout,
+  register,
+} from "talizen/auth";
+
+await register({
+  account: "alice",
+  password: "secret",
+  name: "Alice",
+  email: "hi@talizen.com",
+});
+await login({ account: "alice", password: "secret" });
 
 const user = await currentUser();
 await logout();
+
+const providers = await listAuthProviders();
+console.log(providers.map((provider) => provider.key));
+
+await loginWithOAuth("github", { redirectUrl: "/account" });
 ```
 
 ### Invoke a custom function
@@ -126,38 +143,40 @@ await logout();
 ```ts
 import { invoke } from "talizen/func";
 
-const result = await invoke<{ success: boolean }>("user/auth.login", {
+const result = await invoke<{ ok: boolean; id: string }>("booking.create", {
   email: "hi@talizen.com",
-  password: "secret",
+  date: "2026-07-04",
+  time: "10:00",
 });
 ```
 
 `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" });
+await invoke("booking", { email: "hi@talizen.com" });
 ```
 
 ### Write function runtime code
 
-Func code can use TypeScript and import runtime-only helpers from `talizen/func-runtime`:
+Func code can use TypeScript and import Func authoring types from `talizen/func-runtime`.
+Runtime capabilities are passed through `ctx`:
 
 ```ts
-import { auth, db, cache } from "talizen/func-runtime";
+import type { TalizenFuncContext } from "talizen/func-runtime";
 
-export function create(input: { title: string }) {
-  const user = auth.requireUser();
-  const row = db.insert("book", {
+export function create(input: { title: string }, ctx: TalizenFuncContext) {
+  const user = ctx.auth.requireUser();
+  const row = ctx.db.insert("book", {
     title: input.title,
     user_id: user.id,
     status: "draft",
   });
-  cache.set(`book:${row.id}`, row, 60);
+  ctx.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.
+`ctx.db`, `ctx.cache`, `ctx.auth`, `ctx.request`, and `ctx.cookies` are injected by the Talizen Func runtime. `talizen/func-runtime` is a type-only authoring module; do not import runtime values from it.
 
 ## Package Layout
 
@@ -166,7 +185,7 @@ export function create(input: { title: string }) {
 - `talizen/cms`: CMS content types and content query APIs.
 - `talizen/form`: form submission helpers and related types.
 - `talizen/func`: custom function invocation helpers such as `invoke`.
-- `talizen/func-runtime`: Func-runtime-only `db`, `cache`, and `auth` types.
+- `talizen/func-runtime`: Func-runtime-only `ctx` capability types.
 
 ## Publish
 

package/auth.d.ts

@@ -1,7 +1,14 @@
 import { type TalizenRequestOptions } from "./core.js";
 export interface AuthUser {
     id: string;
+    /**
+     * Login identifier for this project user.
+     * This does not need to be an email address or phone number.
+     */
+    account?: string;
+    /** Optional contact email/profile field, not the primary login identifier. */
     email?: string;
+    /** Optional contact phone/profile field, not the primary login identifier. */
     phone?: string;
     name?: string;
     avatar?: string;
@@ -13,15 +20,34 @@ export interface AuthUser {
     updated_at?: string;
 }
 export interface AuthPasswordInput {
-    email: string;
+    /**
+     * Login identifier for register/login.
+     * Do not substitute email or phone unless the user intentionally uses that
+     * value as their account.
+     */
+    account: string;
     password: string;
 }
 export interface AuthRegisterInput extends AuthPasswordInput {
+    email?: string;
     phone?: string;
     name?: string;
     avatar?: string;
     profile?: unknown;
 }
+export interface AuthProvider {
+    key: string;
+    name: string;
+    scopes?: string;
+    status?: string;
+}
+export interface AuthProviderListResponse {
+    total?: number;
+    list?: AuthProvider[];
+}
+export interface AuthOAuthLoginURLOptions extends TalizenRequestOptions {
+    redirectUrl?: string;
+}
 export declare class TalizenAuthError extends Error {
     constructor(message: string);
 }
@@ -30,3 +56,6 @@ export declare function login(input: AuthPasswordInput, options?: TalizenRequest
 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>;
+export declare function listAuthProviders(options?: TalizenRequestOptions): Promise<AuthProvider[]>;
+export declare function getOAuthLoginUrl(provider: string, options?: AuthOAuthLoginURLOptions): Promise<string>;
+export declare function loginWithOAuth(provider: string, options?: AuthOAuthLoginURLOptions): Promise<void>;

package/auth.js

@@ -33,3 +33,23 @@ export async function requireUser(options) {
     }
     return user;
 }
+export async function listAuthProviders(options) {
+    const response = await requestJson("/auth/provider_list", { method: "GET" }, options);
+    return response.list ?? [];
+}
+export async function getOAuthLoginUrl(provider, options) {
+    const url = new URL("/auth/oauth/login_url", "https://talizen.local");
+    url.searchParams.set("provider", provider);
+    if (options?.redirectUrl) {
+        url.searchParams.set("redirect_url", options.redirectUrl);
+    }
+    const response = await requestJson(url.pathname + url.search, { method: "GET" }, options);
+    return response.url;
+}
+export async function loginWithOAuth(provider, options) {
+    const target = await getOAuthLoginUrl(provider, options);
+    if (typeof window === "undefined" || !window.location) {
+        throw new TalizenAuthError("OAuth login requires a browser window.");
+    }
+    window.location.href = target;
+}

package/func-runtime.d.ts

@@ -60,6 +60,40 @@ export interface FuncCacheRuntime {
         ok?: boolean;
     };
 }
-export declare const db: FuncDbRuntime;
-export declare const auth: FuncAuthRuntime;
-export declare const cache: FuncCacheRuntime;
+export interface FuncReadonlyStringMap {
+    get(name: string): string | null;
+}
+export interface FuncRequestRuntime {
+    host: string;
+    ip: string;
+    method: string;
+    path: string;
+    headers: FuncReadonlyStringMap;
+    cookies: FuncReadonlyStringMap;
+}
+export interface FuncCookieSetOptions {
+    path?: string;
+    domain?: string;
+    maxAge?: number;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "lax" | "strict" | "none";
+}
+export interface FuncCookieRuntime {
+    get(name: string): string | null;
+    set(name: string, value: string, options?: FuncCookieSetOptions): {
+        ok?: boolean;
+    };
+    delete(name: string, options?: Pick<FuncCookieSetOptions, "path" | "domain">): {
+        ok?: boolean;
+    };
+}
+export interface TalizenFuncContext {
+    trace_id: string;
+    extra?: Record<string, unknown>;
+    request: FuncRequestRuntime;
+    db: FuncDbRuntime;
+    auth: FuncAuthRuntime;
+    cache: FuncCacheRuntime;
+    cookies: FuncCookieRuntime;
+}

package/func-runtime.js

@@ -1,21 +1 @@
-function unavailable() {
-    throw new Error("talizen/func-runtime is only available inside Talizen Func runtime.");
-}
-export const db = {
-    get: unavailable,
-    query: unavailable,
-    insert: unavailable,
-    update: unavailable,
-    delete: unavailable,
-};
-export const auth = {
-    currentUser: unavailable,
-    requireUser: unavailable,
-};
-export const cache = {
-    get: unavailable,
-    set: unavailable,
-    del: unavailable,
-    incr: unavailable,
-    expire: unavailable,
-};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",