wirejs-resources 0.1.8-alpha → 0.1.9

package/dist/adapters/context.d.ts

@@ -3,7 +3,7 @@ type ApiMethod = (...args: any) => any;
 type ApiNamespace = {
     [K in string]: ApiMethod | ApiNamespace;
 };
-type ContextfulApiMethod<T> = T extends ((...args: infer ARGS) => infer RT) ? ((context: Context | boolean, ...args: ARGS) => RT extends Promise<any> ? RT : Promise<RT>) : never;
+type ContextfulApiMethod<T> = T extends ((...args: infer ARGS) => infer RT) ? ((context: Context | undefined | null, ...args: ARGS) => RT extends Promise<any> ? RT : Promise<RT>) : never;
 type ContextfulApiNamespace<T> = {
     [K in keyof T]: T[K] extends ApiMethod ? ContextfulApiMethod<T[K]> : ContextfulApiNamespace<T[K]>;
 };

package/dist/adapters/context.js

@@ -1,4 +1,4 @@
-const __requiresContext = Symbol('__requiresContext');
+const __requiresContext = '__requiresContext';
 export function withContext(contextWrapper, path = []) {
     // first param needs to be a function, which enables `Proxy` to implement `apply()`.
     const fnOrNs = new Proxy(function () { }, {
@@ -20,7 +20,11 @@ export function withContext(contextWrapper, path = []) {
     return fnOrNs;
 }
 export function requiresContext(fnOrNS) {
-    return fnOrNS[__requiresContext] === true;
+    Object.defineProperty(fnOrNS, __requiresContext, {
+        enumerable: false,
+        value: true
+    });
+    return true;
 }
 export class Context {
     cookies;

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/client/index.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/derived-types.d.ts

@@ -0,0 +1,2 @@
+import type { AuthenticationService } from "./services/authentication";
+export type AuthenticationApi = ReturnType<AuthenticationService['buildApi']>;

package/dist/derived-types.js

@@ -0,0 +1 @@
+export {};

package/dist/hosting/client.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/hosting/client.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export { CookieJar } from './adapters/cookie-jar.js';
 export { withContext, requiresContext, Context } from './adapters/context.js';
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
+export * from './types.js';
+export * from './derived-types.js';

package/dist/index.js

@@ -4,3 +4,5 @@ export { CookieJar } from './adapters/cookie-jar.js';
 export { withContext, requiresContext, Context } from './adapters/context.js';
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
+export * from './types.js';
+export * from './derived-types.js';

package/dist/internal/client.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/internal/client.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/internal/index.d.ts

@@ -0,0 +1 @@
+export declare function prebuildApi(): Promise<void>;

package/dist/internal/index.js

@@ -0,0 +1,27 @@
+import process from 'process';
+import fs from 'fs';
+import path from 'path';
+export async function prebuildApi() {
+    const CWD = process.cwd();
+    let API_URL = '/api';
+    const indexModule = await import(path.join(CWD, 'index.js'));
+    try {
+        const backendConfigModule = await import(path.join(CWD, 'config.js'));
+        const backendConfig = backendConfigModule.default;
+        console.log("backend config found", backendConfig);
+        if (backendConfig.apiUrl) {
+            API_URL = backendConfig.apiUrl;
+        }
+    }
+    catch {
+        console.log("No backend API config found.");
+    }
+    const apiCode = Object.keys(indexModule)
+        .map(k => `export const ${k} = apiTree(INTERNAL_API_URL, ${JSON.stringify([k])});`)
+        .join('\n');
+    const baseClient = [
+        `import { apiTree } from "wirejs-resources/client";`,
+        `const INTERNAL_API_URL = ${JSON.stringify(API_URL)};`,
+    ].join('\n');
+    await fs.promises.writeFile(path.join(CWD, 'index.client.js'), [baseClient, apiCode].join('\n\n'));
+}

package/dist/services/authentication.d.ts

@@ -1,67 +1,24 @@
 import { Resource } from '../resource.js';
 import type { CookieJar } from '../adapters/cookie-jar.js';
-type AuthenticationInput = {
-    label: string;
-    type: 'text' | 'password';
-    isRequired?: boolean;
-};
-type Action = {
-    name: string;
-    title?: string;
-    description?: string;
-    message?: string;
-    inputs?: Record<string, AuthenticationInput>;
-    buttons?: string[];
-};
-type AuthenticationBaseState = {
-    state: 'authenticated' | 'unauthenticated';
-    user: string | undefined;
-};
-type AuthenticationState = {
-    state: AuthenticationBaseState;
-    message?: string;
-    actions: Record<string, Action>;
-};
-type PerformActionParameter = {
-    key: string;
-    inputs: Record<string, string | number | boolean>;
-    verb: string;
-};
-type AuthenticationError = {
-    message: string;
-    field?: string;
-};
-type AuthenticationServiceOptions = {
-    /**
-     * The number of seconds the authentication session stays alive.
-     */
-    duration?: number;
-    /**
-     * Whether to automatically extend (keep alive) an authentication session when used.
-     */
-    keepalive?: boolean;
-    /**
-     * The name of the cookie to use to store the authentication state JWT.
-     */
-    cookie?: string;
-};
+import type { User, AuthenticationError, AuthenticationMachineInput, AuthenticationMachineState, AuthenticationServiceOptions, AuthenticationState } from '../types.js';
 export declare class AuthenticationService extends Resource {
     #private;
     constructor(scope: Resource | string, id: string, { duration, keepalive, cookie }?: AuthenticationServiceOptions);
     getSigningSecret(): Promise<Uint8Array<ArrayBufferLike>>;
     get signingSecret(): Promise<Uint8Array<ArrayBufferLike>>;
-    getBaseState(cookies: CookieJar): Promise<AuthenticationBaseState>;
     getState(cookies: CookieJar): Promise<AuthenticationState>;
-    setBaseState(cookies: CookieJar, user?: string): Promise<void>;
+    getMachineState(cookies: CookieJar): Promise<AuthenticationMachineState>;
+    setState(cookies: CookieJar, user?: User): Promise<void>;
     missingFieldErrors(input: Record<string, string | number | boolean>, fields: string[]): AuthenticationError[] | undefined;
-    setState(cookies: CookieJar, { key, inputs, verb: _verb }: PerformActionParameter): Promise<AuthenticationState | {
+    setMachineState(cookies: CookieJar, form: AuthenticationMachineInput): Promise<AuthenticationMachineState | {
         errors: AuthenticationError[];
     }>;
     buildApi(this: AuthenticationService): {
-        getState: (context: import("../adapters/context.js").Context | boolean) => Promise<AuthenticationState>;
-        setState: (context: import("../adapters/context.js").Context | boolean, options: PerformActionParameter) => Promise<AuthenticationState | {
+        getState: (context: import("../adapters/context.js").Context | undefined | null) => Promise<AuthenticationMachineState>;
+        setState: (context: import("../adapters/context.js").Context | undefined | null, options: AuthenticationMachineInput) => Promise<AuthenticationMachineState | {
             errors: AuthenticationError[];
         }>;
+        getCurrentUser: (context: import("../adapters/context.js").Context | undefined | null) => Promise<User | null>;
+        requireCurrentUser: (context: import("../adapters/context.js").Context | undefined | null) => Promise<User>;
     };
 }
-export {};

package/dist/services/authentication.js

@@ -1,10 +1,13 @@
-import { scrypt, randomBytes } from 'crypto';
+import { scrypt, randomBytes, randomUUID } from 'crypto';
 import * as jose from 'jose';
 import { Resource } from '../resource.js';
 import { FileService } from './file.js';
 import { Secret } from '../resources/secret.js';
 import { withContext } from '../adapters/context.js';
 import { overrides } from '../overrides.js';
+function newId() {
+    return randomUUID();
+}
 function hash(password, salt) {
     return new Promise((resolve, reject) => {
         const finalSalt = salt || randomBytes(16).toString('hex');
@@ -23,8 +26,160 @@ async function verifyHash(password, passwordHash) {
     const rehashed = await hash(password, saltPart);
     return rehashed === passwordHash;
 }
-// #endregion
+const actions = {
+    changepassword: {
+        name: "Change Password",
+        fields: {
+            existingPassword: {
+                label: 'Old Password',
+                type: 'password',
+            },
+            newPassword: {
+                label: 'New Password',
+                type: 'password',
+            }
+        },
+        buttons: ['Change Password']
+    },
+    signin: {
+        name: "Sign In",
+        fields: {
+            username: {
+                label: 'Username',
+                type: 'text',
+            },
+            password: {
+                label: 'Password',
+                type: 'password',
+            },
+        },
+        buttons: ['Sign In']
+    },
+    signup: {
+        name: "Sign Up",
+        fields: {
+            username: {
+                label: 'Username',
+                type: 'text',
+            },
+            password: {
+                label: 'Password',
+                type: 'password',
+            },
+        },
+        buttons: ['Sign Up']
+    },
+    signout: {
+        name: "Sign out"
+    },
+};
+function machineAction(key) {
+    return {
+        key,
+        ...actions[key]
+    };
+}
+function isAction(input, action) {
+    return input.key === action;
+}
+function hasNonEmptyString(o, k) {
+    return (typeof o === 'object' && k in o && typeof o[k] === 'string' && o[k].length > 0);
+}
+function isInternalUser(candidate) {
+    return (hasNonEmptyString(candidate, 'id')
+        && hasNonEmptyString(candidate, 'password'));
+}
 const ONE_WEEK = 7 * 24 * 60 * 60; // days * hours/day * minutes/hour * seconds/minute
+class UserStore {
+    files;
+    constructor(files) {
+        this.files = files;
+    }
+    async get(username) {
+        try {
+            const data = await this.files.read(`byUsername/${username}.json`);
+            const parsed = JSON.parse(data);
+            return isInternalUser(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async reserveId(username) {
+        const candidateId = newId();
+        try {
+            await this.files.write(`byId/${candidateId}.json`, JSON.stringify({ username }), { onlyIfNotExists: true });
+        }
+        catch (err) {
+            if (this.files.isAlreadyExistsError(err)) {
+                return this.reserveId(username);
+            }
+            else {
+                throw err;
+            }
+        }
+        return candidateId;
+    }
+    async releaseId(id) {
+        return this.files.delete(`byId/${id}.json`);
+    }
+    async createUserEntry(user, retries = 3) {
+        try {
+            await this.files.write(`byUsername/${user.username}.json`, JSON.stringify(user), { onlyIfNotExists: true });
+            return 'ok';
+        }
+        catch (err) {
+            if (this.files.isAlreadyExistsError(err)) {
+                return 'already-exists';
+            }
+            else {
+                if (retries > 0) {
+                    await new Promise(unsleep => setTimeout(unsleep, 500));
+                    return this.createUserEntry(user, retries - 1);
+                }
+                else {
+                    return 'fail';
+                }
+            }
+        }
+    }
+    async create(username, password) {
+        const id = await this.reserveId(username);
+        const user = { id, username, password };
+        const result = await this.createUserEntry(user);
+        switch (result) {
+            case 'already-exists':
+            case 'fail':
+                try {
+                    await this.releaseId(id);
+                }
+                finally {
+                    return result;
+                }
+            case 'ok':
+                return user;
+            default:
+                throw new Error("Unrecognized result from filesystem: " + result);
+        }
+    }
+    async update(username, details) {
+        await this.files.write(`byUsername/${username}`, JSON.stringify(details));
+    }
+    async has(username) {
+        const user = await this.get(username);
+        return !!user;
+    }
+    async getById(id) {
+        try {
+            const idJSON = await this.files.read(`byId/${id}.json`);
+            const { username } = JSON.parse(idJSON);
+            return this.get(username);
+        }
+        catch {
+            return null;
+        }
+    }
+}
 export class AuthenticationService extends Resource {
     #duration;
     ;
@@ -40,28 +195,7 @@ export class AuthenticationService extends Resource {
         this.#cookieName = cookie ?? 'identity';
         this.#rawSigningSecret = new (overrides.Secret || Secret)(this, 'jwt-signing-secret');
         const fileService = new (overrides.FileService || FileService)(this, 'files');
-        this.#users = {
-            id,
-            async get(username) {
-                try {
-                    const data = await fileService.read(this.filenameFor(username));
-                    return JSON.parse(data);
-                }
-                catch {
-                    return undefined;
-                }
-            },
-            async set(username, details) {
-                await fileService.write(this.filenameFor(username), JSON.stringify(details));
-            },
-            async has(username) {
-                const user = await this.get(username);
-                return !!user;
-            },
-            filenameFor(username) {
-                return `${username}.json`;
-            }
-        };
+        this.#users = new UserStore(fileService);
     }
     async getSigningSecret() {
         const secretAsString = await this.#rawSigningSecret.read();
@@ -73,13 +207,17 @@ export class AuthenticationService extends Resource {
         }
         return this.#signingSecret;
     }
-    async getBaseState(cookies) {
+    async getState(cookies) {
         let idCookie;
         let user;
         try {
             idCookie = cookies.get(this.#cookieName)?.value;
             const idPayload = idCookie ? (await jose.jwtVerify(idCookie, await this.signingSecret)) : undefined;
-            user = idPayload ? idPayload.payload.sub : undefined;
+            user = idPayload ? {
+                id: idPayload.payload.sub,
+                username: idPayload.payload.username,
+                displayName: idPayload.payload.username,
+            } : undefined;
         }
         catch (err) {
             // jose doesn't like our cookie.
@@ -98,79 +236,38 @@ export class AuthenticationService extends Resource {
             };
         }
     }
-    async getState(cookies) {
-        const state = await this.getBaseState(cookies);
+    async getMachineState(cookies) {
+        const state = await this.getState(cookies);
         if (state.state === 'authenticated') {
             if (this.#keepalive)
-                this.setBaseState(cookies, state.user);
+                this.setState(cookies, state.user);
             return {
-                state,
+                ...state,
                 actions: {
-                    changepassword: {
-                        name: "Change Password",
-                        inputs: {
-                            existingPassword: {
-                                label: 'Old Password',
-                                type: 'password',
-                            },
-                            newPassword: {
-                                label: 'New Password',
-                                type: 'password',
-                            }
-                        },
-                        buttons: ['Change Password']
-                    },
-                    signout: {
-                        name: "Sign out"
-                    },
+                    changepassword: machineAction('changepassword'),
+                    signout: machineAction('signout'),
                 }
             };
         }
         else {
             return {
-                state,
+                ...state,
                 actions: {
-                    signin: {
-                        name: "Sign In",
-                        inputs: {
-                            username: {
-                                label: 'Username',
-                                type: 'text',
-                            },
-                            password: {
-                                label: 'Password',
-                                type: 'password',
-                            },
-                        },
-                        buttons: ['Sign In']
-                    },
-                    signup: {
-                        name: "Sign Up",
-                        inputs: {
-                            username: {
-                                label: 'Username',
-                                type: 'text',
-                            },
-                            password: {
-                                label: 'Password',
-                                type: 'password',
-                            },
-                        },
-                        buttons: ['Sign Up']
-                    },
+                    signin: machineAction('signin'),
+                    signup: machineAction('signup'),
                 }
             };
         }
     }
-    async setBaseState(cookies, user) {
+    async setState(cookies, user) {
         if (!user) {
             cookies.delete(this.#cookieName);
         }
         else {
-            const jwt = await new jose.SignJWT({})
+            const jwt = await new jose.SignJWT(user)
                 .setProtectedHeader({ alg: 'HS256' })
                 .setIssuedAt()
-                .setSubject(user)
+                .setSubject(user.id)
                 .setExpirationTime(`${this.#duration}s`)
                 .sign(await this.signingSecret);
             cookies.set({
@@ -193,34 +290,39 @@ export class AuthenticationService extends Resource {
         }
         return errors.length > 0 ? errors : undefined;
     }
-    async setState(cookies, { key, inputs, verb: _verb }) {
-        if (key === 'signout') {
-            await this.setBaseState(cookies, undefined);
-            return this.getState(cookies);
+    async setMachineState(cookies, form) {
+        if (isAction(form, 'signout')) {
+            await this.setState(cookies, undefined);
+            return this.getMachineState(cookies);
         }
-        else if (key === 'signup') {
-            const errors = this.missingFieldErrors(inputs, ['username', 'password']);
+        else if (isAction(form, 'signup')) {
+            const errors = this.missingFieldErrors(form.inputs, ['username', 'password']);
             if (errors) {
                 return { errors };
             }
-            else if (await this.#users.has(inputs.username)) {
+            const createResult = await this.#users.create(form.inputs.username, await hash(form.inputs.password));
+            if (createResult === 'already-exists') {
                 return { errors: [{
                             field: 'username',
                             message: 'User already exists.'
-                        }]
-                };
+                        }] };
+            }
+            else if (createResult === 'fail') {
+                return { errors: [{
+                            message: 'Internal error. Please try again.'
+                        }] };
             }
             else {
-                await this.#users.set(inputs.username, {
-                    id: inputs.username,
-                    password: await hash(inputs.password)
+                await this.setState(cookies, {
+                    id: createResult.id,
+                    username: createResult.username,
+                    displayName: createResult.username,
                 });
-                await this.setBaseState(cookies, inputs.username);
-                return this.getState(cookies);
+                return this.getMachineState(cookies);
             }
         }
-        else if (key === 'signin') {
-            const user = await this.#users.get(inputs.username);
+        else if (isAction(form, 'signin')) {
+            const user = await this.#users.get(form.inputs.username);
             if (!user) {
                 return { errors: [{
                             field: 'username',
@@ -228,11 +330,15 @@ export class AuthenticationService extends Resource {
                         }]
                 };
             }
-            else if (await verifyHash(inputs.password, user.password)) {
+            else if (await verifyHash(form.inputs.password, user.password)) {
                 // a real authentication service will use password hashing.
                 // this is an in-memory just-for-testing user pool.
-                await this.setBaseState(cookies, inputs.username);
-                return this.getState(cookies);
+                await this.setState(cookies, {
+                    id: user.id,
+                    username: user.username,
+                    displayName: user.username,
+                });
+                return this.getMachineState(cookies);
             }
             else {
                 return { errors: [{
@@ -242,9 +348,9 @@ export class AuthenticationService extends Resource {
                 };
             }
         }
-        else if (key === 'changepassword') {
-            const state = await this.getBaseState(cookies);
-            const user = await this.#users.get(state.user);
+        else if (isAction(form, 'changepassword')) {
+            const state = await this.getState(cookies);
+            const user = state.user ? await this.#users.get(state.user.username) : null;
             if (!user) {
                 return { errors: [{
                             field: 'username',
@@ -252,14 +358,14 @@ export class AuthenticationService extends Resource {
                         }]
                 };
             }
-            else if (await verifyHash(inputs.existingPassword, user.password)) {
-                await this.#users.set(user.id, {
+            else if (await verifyHash(form.inputs.existingPassword, user.password)) {
+                await this.#users.update(user.username, {
                     ...user,
-                    password: await hash(inputs.newPassword)
+                    password: await hash(form.inputs.newPassword)
                 });
                 return {
+                    ...await this.getMachineState(cookies),
                     message: "Password updated.",
-                    ...await this.getState(cookies)
                 };
             }
             else {
@@ -279,8 +385,26 @@ export class AuthenticationService extends Resource {
     }
     buildApi() {
         return withContext(context => ({
-            getState: () => this.getState(context.cookies),
-            setState: (options) => this.setState(context.cookies, options),
+            getState: () => this.getMachineState(context.cookies),
+            setState: (options) => this.setMachineState(context.cookies, options),
+            getCurrentUser: async () => {
+                const state = await this.getState(context.cookies);
+                if (state.state === 'authenticated' && state.user) {
+                    return state.user;
+                }
+                else {
+                    return null;
+                }
+            },
+            requireCurrentUser: async () => {
+                const state = await this.getState(context.cookies);
+                if (state.state === 'authenticated' && state.user) {
+                    return state.user;
+                }
+                else {
+                    throw new Error("Unauthorized.");
+                }
+            }
         }));
     }
 }

package/dist/setup/index.d.ts

@@ -0,0 +1 @@
+export declare function prebuildApi(): Promise<void>;

package/dist/setup/index.js

@@ -0,0 +1,27 @@
+import process from 'process';
+import fs from 'fs';
+import path from 'path';
+export async function prebuildApi() {
+    const CWD = process.cwd();
+    let API_URL = '/api';
+    const indexModule = await import(path.join(CWD, 'index.js'));
+    try {
+        const backendConfigModule = await import(path.join(CWD, 'config.js'));
+        const backendConfig = backendConfigModule.default;
+        console.log("backend config found", backendConfig);
+        if (backendConfig.apiUrl) {
+            API_URL = backendConfig.apiUrl;
+        }
+    }
+    catch {
+        console.log("No backend API config found.");
+    }
+    const apiCode = Object.keys(indexModule)
+        .map(k => `export const ${k} = apiTree(INTERNAL_API_URL, ${JSON.stringify([k])});`)
+        .join('\n');
+    const baseClient = [
+        `import { apiTree } from "wirejs-resources/hosting/client.js";`,
+        `const INTERNAL_API_URL = ${JSON.stringify(API_URL)};`,
+    ].join('\n');
+    await fs.promises.writeFile(path.join(CWD, 'index.client.js'), [baseClient, apiCode].join('\n\n'));
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+export type User = {
+    /**
+     * Something that uniquely identifies the user in the authentication system
+     * and does not change over time.
+     */
+    id: string;
+    /**
+     * The self-identifier the user has chosen to log in with.
+     */
+    username: string;
+    /**
+     * The name this user will be known by to other users.
+     */
+    displayName: string;
+};
+export type AuthenticationField = {
+    label: string;
+    type: 'text' | 'password';
+    isRequired?: boolean;
+};
+export type AuthenticationAction = {
+    name: string;
+    title?: string;
+    description?: string;
+    message?: string;
+    fields?: Record<string, AuthenticationField>;
+    buttons?: readonly string[];
+};
+export type AuthenticationState = {
+    state: 'authenticated' | 'unauthenticated';
+    user: User | undefined;
+};
+export type AuthenticationMachineAction = Readonly<AuthenticationAction & {
+    key: string;
+}>;
+export type AuthenticationMachineState = AuthenticationState & {
+    message?: string;
+    actions: Record<string, AuthenticationMachineAction>;
+};
+export type AuthenticationMachineInput = {
+    key: string;
+    inputs?: Record<string, string | number | boolean>;
+    verb?: string;
+};
+export type AuthenticationMachineInputFor<T extends AuthenticationMachineAction> = {
+    key: T['key'];
+    verb: string;
+    inputs: T['fields'] extends undefined ? Record<string, never> : {
+        [K in keyof T['fields']]: FieldInputFor<T['fields'][K]>;
+    };
+};
+export type FieldInputFor<T> = T extends AuthenticationField ? T['type'] extends ('text' | 'password') ? string : never : never;
+export type AuthenticationError = {
+    message: string;
+    field?: string;
+};
+export type AuthenticationServiceOptions = {
+    /**
+     * The number of seconds the authentication session stays alive.
+     */
+    duration?: number;
+    /**
+     * Whether to automatically extend (keep alive) an authentication session when used.
+     */
+    keepalive?: boolean;
+    /**
+     * The name of the cookie to use to store the authentication state JWT.
+     */
+    cookie?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,14 +1,22 @@
 {
 	"name": "wirejs-resources",
-	"version": "0.1.8-alpha",
+	"version": "0.1.9",
 	"description": "Basic services and server-side resources for wirejs apps",
 	"type": "module",
 	"main": "./dist/index.js",
-	"types": "./dist/types.d.ts",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js"
+		},
+		"./internal": {
+			"types": "./dist/internal/index.d.ts",
+			"default": "./dist/internal/index.js"
+		},
+		"./client": {
+			"types": "./dist/client/index.d.ts",
+			"default": "./dist/client/index.js"
 		}
 	},
 	"scripts": {