@trylight/app 0.3.9 → 0.3.12

package/README.md

@@ -8,8 +8,8 @@ its tables and their typed client, its door, its contracts and its chat.
 | Import | What |
 |---|---|
 | `@trylight/app/schema` | `entity(name, columns, access)`: a Drizzle table plus `id`, `created_at`, `updated_at`, `created_by`, `field_sources`; `lightChanges` (the audit table); `lightImages` (the app's copy of its logos and photos); `fieldSource` (the `{url, evidence}` schema) |
-| `@trylight/app` | `createApp<typeof contracts>()` → `app.table(entity)` (`list/get/create/update/delete`, `useList/useInfiniteList/useGet/useCreate/useUpdate/useDelete`, typed by the entity passed; `useList(...).rows` is never undefined), `app.contracts` (`useInvocation`), and `imageSrc(url)` (where a logo or photo loads from) |
-| `@trylight/app/server` | `createLightServer({ schema, contracts })` → `light.db` (Drizzle), `light.session(request)`, `light.signIn(email, password)`, and the route handlers `light.entities`, `light.image`, `light.invoke.handler`, `light.chat` |
+| `@trylight/app` | `createApp<typeof contracts>()` → `app.table(entity)` (`list/get/create/update/delete`, `useList/useInfiniteList/useCount/useGet/useCreate/useUpdate/useDelete`, typed by the entity passed; `useList(...).rows` is never undefined), `app.contracts` (`useInvocation`), and `imageSrc(url)` (where a logo or photo loads from) |
+| `@trylight/app/server` | `createLightServer({ schema, contracts })` → `light.db` (Drizzle), `light.session(request)`, `light.signIn(email, password, code?)`, and the route handlers `light.entities`, `light.image`, `light.invoke.handler`, `light.chat` |
 | `@trylight/app/platform` | the door for server functions, framing, analytics/error policies, the pane bridge, `fetchThroughRestart` (`createStart`'s `serverFns.fetch`) |
 | `@trylight/app/vite` | `lightDb()`: the dev server syncs `db/schema` into the database on every change |
 | `light-db` (bin) | `sync`, `migrate`, `check`: the app's `pnpm db:*` scripts |
@@ -37,7 +37,9 @@ new ones load (`isSwitching`), sorts on the server, and prefetches the
 sibling views it is given once it settles. A write refetches every page a
 list has loaded, one after another, before its mutation settles; the
 change itself shows at once. `search` matches words in any
-text column, case-insensitively, on the server.
+text column, case-insensitively, on the server. `useCount({ where, search })` is how
+many rows the same list would hold, counted on the server (a paged list's tab
+total), and refetched after every write like the rest.
 
 Joins and aggregates stay typed server functions over `light.db`.
 

package/dist/auth/plaza.d.ts

@@ -25,7 +25,7 @@ export type PlazaSession = {
  * (the platform unreachable, the platform answering nonsense), so the route can report them.
  */
 export type SignInFailure = {
-    readonly kind: "credentials" | "not_a_member" | "throttled";
+    readonly kind: "credentials" | "not_a_member" | "unverified" | "throttled" | "code_required" | "wrong_code" | "two_factor_not_set_up";
     readonly message: string;
 } | {
     readonly kind: "unavailable";
@@ -44,9 +44,10 @@ export type SignInResult = ({
 };
 /**
  * Check an email and password with the platform, and get back who the person is and
- * the session the platform signed for them.
+ * the session the platform signed for them. `code` is from their authenticator app,
+ * sent once the platform has asked for it.
  */
-export declare function signInWithPlaza(email: string, password: string): Promise<SignInResult>;
+export declare function signInWithPlaza(email: string, password: string, code?: string): Promise<SignInResult>;
 export type PasswordResetResult = {
     readonly ok: true;
 } | {

package/dist/auth/plaza.js

@@ -1,18 +1,19 @@
 import { z } from "zod/v4";
 import { miiAuthConfig } from "./config.js";
-import { PLATFORM_AUTH_PATHS } from "../platform/contract.js";
+import { EMAIL_NOT_VERIFIED_REFUSAL, PLATFORM_AUTH_PATHS } from "../platform/contract.js";
 /**
  * Check an email and password with the platform, and get back who the person is and
- * the session the platform signed for them.
+ * the session the platform signed for them. `code` is from their authenticator app,
+ * sent once the platform has asked for it.
  */
-export async function signInWithPlaza(email, password) {
+export async function signInWithPlaza(email, password, code) {
     const { plazaUrl, appId } = miiAuthConfig();
     let response;
     try {
         response = await fetch(`${plazaUrl}${PLATFORM_AUTH_PATHS.signIn}`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ appId, email, password }),
+            body: JSON.stringify({ appId, email, password, code: typedCode.parse(code) }),
             cache: "no-store"
         });
     }
@@ -46,6 +47,12 @@ export async function signInWithPlaza(email, password) {
         failure: failureFor(response.status, await response.text())
     };
 }
+/** A blank code field is no code: the platform refuses an empty one outright. */
+const typedCode = z
+    .string()
+    .trim()
+    .transform((typed) => (typed === "" ? undefined : typed))
+    .optional();
 /** `returnTo` is this app's login, where the platform's reset page sends the person afterwards. */
 export async function requestPasswordResetWithPlaza(email, returnTo) {
     const { plazaUrl, appId } = miiAuthConfig();
@@ -155,11 +162,33 @@ function asSignedIn(body) {
     const { session, ...identity } = read.data;
     return { identity, session };
 }
+// A 403 is also "not a member"; the refusal's code tells them apart.
+const unverifiedRefusal = z.object({ error: z.literal(EMAIL_NOT_VERIFIED_REFUSAL) });
+// Not every answer is JSON: a proxy's error page, say.
+function jsonIn(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+}
 function failureFor(status, body) {
+    const answer = jsonIn(body);
+    const refusal = codeRefusal.safeParse(answer);
+    if (refusal.success) {
+        return { kind: refusal.data.error, message: refusal.data.detail };
+    }
     if (status === 401) {
         return { kind: "credentials", message: "Wrong email or password." };
     }
     if (status === 403) {
+        if (unverifiedRefusal.safeParse(answer).success) {
+            return {
+                kind: "unverified",
+                message: "Confirm your email first: we sent you a link."
+            };
+        }
         return {
             kind: "not_a_member",
             // Said plainly: they have just proved they own the account, so this is
@@ -179,3 +208,8 @@ function failureFor(status, body) {
         cause: new Error(`Platform sign-in answered ${status}: ${body.slice(0, 300)}`)
     };
 }
+// The refusals the platform words itself: it knows the lockout and the setup path.
+const codeRefusal = z.object({
+    error: z.enum(["code_required", "wrong_code", "two_factor_not_set_up", "throttled"]),
+    detail: z.string().min(1)
+});

package/dist/auth/problems.js

@@ -13,6 +13,10 @@ export const SIGN_IN_PROBLEMS = {
         title: "That account can't open this app",
         body: "The password was right, but the account isn't in this app's org. Ask whoever runs it to add you."
     },
+    unverified: {
+        title: "Confirm your email first",
+        body: "We emailed you a link. Open it, then sign in here again."
+    },
     deactivated: {
         title: "Your access here has been turned off",
         body: "Ask whoever runs this app to turn it back on."

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { type QueryKey } from "@tanstack/react-query";
 import type { Contracts } from "./invoke/server.js";
-import { EntityError, type ListOptions, type NewRow, type Patch, type Row } from "./entities.js";
+import { EntityError, type CountOptions, type ListOptions, type NewRow, type Patch, type Row } from "./entities.js";
 import type { Entity } from "./schema.js";
 declare module "@tanstack/react-query" {
     interface Register {
@@ -10,7 +10,7 @@ declare module "@tanstack/react-query" {
         };
     }
 }
-export { EntityError, LIST_LIMIT, type ListOptions, type NewRow, type Sort, type Patch, type Row, type Where } from "./entities.js";
+export { EntityError, LIST_LIMIT, type CountOptions, type ListOptions, type NewRow, type Sort, type Patch, type Row, type Where } from "./entities.js";
 export type { FieldSource, FieldSources } from "./schema.js";
 export { siteOf } from "./schema.js";
 export { imageSrc } from "./images.js";
@@ -81,6 +81,7 @@ declare function tableClient<T extends Entity>(entity: T): {
      */
     key: string[];
     list: (options?: ListOptions<Row<T>>) => Promise<Row<T>[]>;
+    count: (options?: CountOptions<Row<T>>) => Promise<number>;
     get: (id: string) => Promise<Row<T>>;
     create: (data: NewRow<T>) => Promise<Row<T>>;
     update: (id: string, patch: Patch<T>) => Promise<Row<T>>;
@@ -695,6 +696,14 @@ declare function tableClient<T extends Entity>(entity: T): {
         isEnabled: boolean;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     };
+    /**
+     * How many rows match, counted on the server, so a paged list's tab can
+     * show its total; refetched after any write to this table. New options
+     * keep the last count until theirs lands.
+     *
+     *   const drafts = app.table(posts).useCount({ where: { status: "draft" } });
+     */
+    useCount: (options?: CountOptions<Row<T>>) => import("@tanstack/react-query").UseQueryResult<number, EntityError>;
     /** One row; `null` waits (nothing open yet). */
     useGet: (id: string | null) => import("@tanstack/react-query").UseQueryResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError>;
     useCreate: () => import("@tanstack/react-query").UseMutationResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError, NewRow<T>, unknown>;

package/dist/client.js

@@ -132,10 +132,12 @@ function tableClient(entity) {
         all,
         list: (options) => [...all, "list", options],
         pages: (options) => [...all, "pages", options],
+        count: (options) => [...all, "count", options],
         get: (id) => [...all, "get", id],
         write: [...all, "write"]
     };
     const list = (options = {}) => call("GET", `${base}?q=${encodeURIComponent(JSON.stringify(options))}`);
+    const count = (options = {}) => call("GET", `${base}?count=${encodeURIComponent(JSON.stringify(options))}`);
     const get = (id) => call("GET", `${base}/${id}`);
     const create = (data) => call("POST", base, json(data));
     const update = (id, patch) => call("PATCH", `${base}/${id}`, json(patch));
@@ -187,6 +189,7 @@ function tableClient(entity) {
          */
         key: keys.all,
         list,
+        count,
         get,
         create,
         update,
@@ -272,6 +275,14 @@ function tableClient(entity) {
             };
             return { ...query, ...view };
         },
+        /**
+         * How many rows match, counted on the server, so a paged list's tab can
+         * show its total; refetched after any write to this table. New options
+         * keep the last count until theirs lands.
+         *
+         *   const drafts = app.table(posts).useCount({ where: { status: "draft" } });
+         */
+        useCount: (options = {}) => useQuery({ queryKey: keys.count(options), queryFn: () => count(options), placeholderData: keepPreviousData }),
         /** One row; `null` waits (nothing open yet). */
         useGet: (id) => useQuery({
             queryKey: keys.get(id),

package/dist/entities.d.ts

@@ -27,6 +27,8 @@ export type ListOptions<R> = {
     limit?: number;
     offset?: number;
 };
+/** What `useCount` takes: the rows a list with the same `where` and `search` would hold. */
+export type CountOptions<R> = Pick<ListOptions<R>, "where" | "search">;
 /** A refused or failed entities call, with the route's own reason. */
 export declare class EntityError extends Error {
     readonly status: number;

package/dist/platform/contract.d.ts

@@ -16,6 +16,8 @@ export declare const PLATFORM_AUTH_PATHS: {
     /** "Continue with Google / Microsoft": the platform signs the person in and returns with a one-time code. */
     socialSignIn: string;
 };
+/** The platform's sign-in refusing a right password: the login's address is unconfirmed (a 403, like "not a member"). */
+export declare const EMAIL_NOT_VERIFIED_REFUSAL = "email_not_verified";
 /** An app's server calling the platform as the app, for a visitor with no session: which app, and its secret. */
 export declare const APP_CALLER_HEADERS: {
     appId: string;

package/dist/platform/contract.js

@@ -22,6 +22,8 @@ export const PLATFORM_AUTH_PATHS = {
     /** "Continue with Google / Microsoft": the platform signs the person in and returns with a one-time code. */
     socialSignIn: "/api/app-auth/social"
 };
+/** The platform's sign-in refusing a right password: the login's address is unconfirmed (a 403, like "not a member"). */
+export const EMAIL_NOT_VERIFIED_REFUSAL = "email_not_verified";
 /** An app's server calling the platform as the app, for a visitor with no session: which app, and its secret. */
 export const APP_CALLER_HEADERS = { appId: "x-app-id", secret: "x-app-secret" };
 /** The server env that secret is provisioned in. */

package/dist/server/entities.js

@@ -1,4 +1,4 @@
-// The one route behind `app.table(...)`: list, get, create, update and delete
+// The one route behind `app.table(...)`: list, count, get, create, update and delete
 // on any entity table, each request checked against the table's own Zod
 // schema and the app's door. Each write names its person for the table's
 // trigger, which records the change in light_changes (src/db/audit.ts), which
@@ -82,7 +82,10 @@ export function createEntitiesHandler(options) {
         if (method === "GET") {
             if (!mayRead(session))
                 return refuse(401, "not_signed_in", "Sign in to use this app.");
-            return id === null ? list(db, table, url) : answer(() => get(db, table, id));
+            if (id !== null)
+                return answer(() => get(db, table, id));
+            const counted = url.searchParams.get("count");
+            return counted === null ? list(db, table, url) : count(db, table, counted);
         }
         if (table.entity.$access.write === "agents") {
             return refuse(403, "agents_only", `${table.name} is written by the org's agents, not from the app.`);
@@ -133,6 +136,10 @@ function tableRules(entity) {
         .filter(([name, c]) => !(name in PLATFORM_COLUMNS) && SEARCHED_TYPES.has(c.columnType))
         .map(([, c]) => c);
     const match = Object.fromEntries(Object.entries(createSelectSchema(entity).shape).map(([key, value]) => [key, z.union([value, z.array(value)])]));
+    const filters = {
+        where: z.object(match).partial().strict().default({}),
+        search: z.string().trim().max(SEARCH_MAX).default("")
+    };
     return {
         name: getTableName(entity),
         entity,
@@ -143,13 +150,13 @@ function tableRules(entity) {
         update: writable(createUpdateSchema(entity).shape),
         list: z
             .object({
-            where: z.object(match).partial().strict().default({}),
-            search: z.string().trim().max(SEARCH_MAX).default(""),
+            ...filters,
             sort: z.literal([...names, ...names.map((name) => `-${name}`)]).default("-created_at"),
             limit: z.int().min(1).max(LIST_LIMIT).default(LIST_LIMIT),
             offset: z.int().min(0).default(0)
         })
-            .strict()
+            .strict(),
+        count: z.object(filters).strict()
     };
 }
 async function list(db, table, url) {
@@ -159,6 +166,28 @@ async function list(db, table, url) {
         return refuse(400, "invalid", z.prettifyError(query.error));
     const { where, search, sort, limit, offset } = query.data;
     const order = sort.startsWith("-") ? desc(table.column(sort.slice(1))) : asc(table.column(sort));
+    const rows = await db
+        .select()
+        .from(table.entity)
+        .where(and(...matching(table, where, search)))
+        // The id breaks ties, so paging with offset never repeats or skips a row.
+        .orderBy(order, asc(table.id))
+        .limit(limit)
+        .offset(offset);
+    return Response.json(rows);
+}
+/** How many rows a list with the same `where` and `search` would hold, without fetching them. */
+async function count(db, table, asked) {
+    const query = table.count.safeParse(readJson(asked));
+    if (!query.success)
+        return refuse(400, "invalid", z.prettifyError(query.error));
+    const rows = await db
+        .select({ count: sql `count(*)::int` })
+        .from(table.entity)
+        .where(and(...matching(table, query.data.where, query.data.search)));
+    return Response.json(exactlyOne(rows).count);
+}
+function matching(table, where, search) {
     const conditions = Object.entries(where).map(([name, value]) => {
         const column = table.column(name);
         if (value === null)
@@ -172,15 +201,7 @@ async function list(db, table, url) {
         const pattern = `%${word.replace(/[\\%_]/g, (c) => `\\${c}`)}%`;
         conditions.push(or(...table.searched.map((column) => ilike(column, pattern))) ?? sql `false`);
     }
-    const rows = await db
-        .select()
-        .from(table.entity)
-        .where(and(...conditions))
-        // The id breaks ties, so paging with offset never repeats or skips a row.
-        .orderBy(order, asc(table.id))
-        .limit(limit)
-        .offset(offset);
-    return Response.json(rows);
+    return conditions;
 }
 /** Members-only: someone signed in; anyone with the link (and a local dev server): anyone. */
 function mayRead(session) {

package/dist/server/index.d.ts

@@ -13,8 +13,8 @@ export declare function createLightServer<S extends Record<string, unknown>, C e
     session: (request: Request) => Promise<import("./session.js").SessionState>;
     /** Whether sign-in is configured (a bare local dev server has none). */
     configured: () => boolean;
-    /** Email and password, checked by the platform; the session to set as a cookie, or why not. */
-    signIn: (email: string, password: string) => Promise<import("./session.js").SignIn>;
+    /** Email and password (and the authenticator code once asked for), checked by the platform; the session to set as a cookie, or why not. */
+    signIn: (email: string, password: string, code?: string) => Promise<import("./session.js").SignIn>;
     requestPasswordReset: (email: string, returnTo: string) => Promise<import("./session.js").PasswordResetRequest>;
     /** The app's database, typed by its schema: `light.db.select().from(companies)`. */
     readonly db: PostgresJsDatabase<S>;

package/dist/server/index.js

@@ -36,8 +36,8 @@ export function createLightServer(options) {
         session,
         /** Whether sign-in is configured (a bare local dev server has none). */
         configured: () => env().configured,
-        /** Email and password, checked by the platform; the session to set as a cookie, or why not. */
-        signIn: (email, password) => signIn(auth, email, password),
+        /** Email and password (and the authenticator code once asked for), checked by the platform; the session to set as a cookie, or why not. */
+        signIn: (email, password, code) => signIn(auth, email, password, code),
         requestPasswordReset: (email, returnTo) => requestPasswordReset(email, returnTo),
         /** The app's database, typed by its schema: `light.db.select().from(companies)`. */
         get db() {

package/dist/server/session.d.ts

@@ -10,12 +10,15 @@ export type SignIn = {
     ok: true;
     token: string;
     expiresAt: Date;
-} | {
+}
+/** `needsCode`: show a field for the authenticator code and send it with the password again. */
+ | {
     ok: false;
     message: string;
+    needsCode: boolean;
 };
 /** The login form's whole job: the platform checks the password, the app starts a session. */
-export declare function signIn(auth: MiiAuthCore, email: string, password: string): Promise<SignIn>;
+export declare function signIn(auth: MiiAuthCore, email: string, password: string, code?: string): Promise<SignIn>;
 export type PasswordResetRequest = {
     ok: true;
 } | {

package/dist/server/session.js

@@ -21,15 +21,17 @@ export async function readSession(auth, request) {
     return { user: { id, name, email, avatarUrl, role }, mode };
 }
 /** The login form's whole job: the platform checks the password, the app starts a session. */
-export async function signIn(auth, email, password) {
+export async function signIn(auth, email, password, code) {
     if (!env().configured)
-        return { ok: false, message: "Sign-in is not configured." };
-    const result = await signInWithPlaza(email, password);
-    if (!result.ok)
-        return { ok: false, message: result.failure.message };
+        return { ok: false, message: "Sign-in is not configured.", needsCode: false };
+    const result = await signInWithPlaza(email, password, code);
+    if (!result.ok) {
+        const { kind, message } = result.failure;
+        return { ok: false, message, needsCode: kind === "code_required" || kind === "wrong_code" };
+    }
     const member = await auth.upsertMemberFromIdentity(result.identity);
     if (member.status !== "active") {
-        return { ok: false, message: "Your account is not active in this workspace." };
+        return { ok: false, message: "Your account is not active in this workspace.", needsCode: false };
     }
     const session = await auth.issueSession(member.id, result.session);
     return { ok: true, ...session };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trylight/app",
-  "version": "0.3.9",
+  "version": "0.3.12",
   "description": "The Light SDK every v2 org app depends on: entities (Drizzle tables with a typed client), sign-in, contracts and in-app chat.",
   "license": "UNLICENSED",
   "type": "module",