talizen 0.2.7 → 0.2.9

package/README.md

@@ -112,7 +112,15 @@ When a `File` object appears in the payload, `submitForm()` will:
 ### Login users
 
 ```ts
-import { currentUser, login, logout, register } from "talizen/auth";
+import {
+  currentUser,
+  listAuthProviders,
+  login,
+  loginWithOAuth,
+  logout,
+  register,
+  updateProfile,
+} from "talizen/auth";
 
 await register({
   account: "alice",
@@ -123,7 +131,15 @@ await register({
 await login({ account: "alice", password: "secret" });
 
 const user = await currentUser();
+await updateProfile({
+  address: "No. 1 Example Road",
+});
 await logout();
+
+const providers = await listAuthProviders();
+console.log(providers.map((provider) => provider.key));
+
+await loginWithOAuth("github", { redirectUrl: "/account" });
 ```
 
 ### Invoke a custom function
@@ -146,24 +162,25 @@ 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
 
@@ -172,7 +189,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

@@ -13,12 +13,13 @@ export interface AuthUser {
     name?: string;
     avatar?: string;
     status?: string;
-    profile?: unknown;
+    profile?: AuthProfile;
     email_verified_at?: string | null;
     last_login_at?: string | null;
     created_at?: string;
     updated_at?: string;
 }
+export type AuthProfile = Record<string, unknown>;
 export interface AuthPasswordInput {
     /**
      * Login identifier for register/login.
@@ -33,7 +34,20 @@ export interface AuthRegisterInput extends AuthPasswordInput {
     phone?: string;
     name?: string;
     avatar?: string;
-    profile?: unknown;
+    profile?: AuthProfile;
+}
+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);
@@ -42,4 +56,8 @@ export declare function register(input: AuthRegisterInput, options?: TalizenRequ
 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 updateProfile(profile: AuthProfile, options?: TalizenRequestOptions): Promise<AuthUser>;
 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

@@ -26,6 +26,12 @@ export async function logout(options) {
 export async function currentUser(options) {
     return requestJson("/auth/me", { method: "GET" }, options);
 }
+export async function updateProfile(profile, options) {
+    return requestJson("/auth/me/profile", {
+        method: "PUT",
+        body: JSON.stringify({ profile }),
+    }, options);
+}
 export async function requireUser(options) {
     const user = await currentUser(options);
     if (!user) {
@@ -33,3 +39,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.7",
+  "version": "0.2.9",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",