@shaferllc/keel 0.82.0 → 0.83.1

package/README.md

@@ -160,7 +160,7 @@ src/core/            The framework
 src/db/              Database adapters (D1, Postgres, libSQL)
 src/api/             CRUD REST resources from a model
 src/openapi/         Generates an OpenAPI spec from the routes
-src/billing/         Subscription billing — Stripe + Paddle (Cashier port)
+src/billing/         Subscription billing — Stripe + Paddle
 src/watch/           The debug dashboard
 src/mcp/             The MCP server (docs + API for AI agents)
 src/vite/            The Vite plugin
@@ -228,7 +228,7 @@ See [docs/architecture.md](./docs/architecture.md) for the full picture.
 | [Internationalization](./docs/i18n.md) | ICU messages, `Intl` formatters, locale detection |
 | [Pages](./docs/pages.md) | Page-based routing — a file is a route |
 | [Packages](./docs/packages.md) | Redistributable slices of an app: routes, migrations, commands |
-| [Billing](./docs/billing.md) | Subscriptions, charges & webhooks — Stripe + Paddle (Cashier port) |
+| [Billing](./docs/billing.md) | Subscriptions, charges & webhooks — Stripe + Paddle |
 | [Watch](./docs/watch.md) | Debug dashboard — requests, queries, jobs, logs at `/watch` |
 | [Views](./docs/views.md) | Hono JSX components, layouts, the View service |
 | [Templates](./docs/templates.md) | `{{ }}` + `@`-tag templating engine, edge-safe |

package/dist/billing/billable.d.ts

@@ -1,7 +1,6 @@
 /**
- * The `Billable` mixin — Cashier's Billable trait, as a TypeScript mixin. Apply
- * it to a model to give that model a gateway customer, subscriptions, charges,
- * and checkout:
+ * The `Billable` mixin — apply it to a model to give that model a gateway
+ * customer, subscriptions, charges, and checkout:
  *
  *   class User extends Billable(Model) {
  *     static table = "users";

package/dist/billing/billable.js

@@ -1,7 +1,6 @@
 /**
- * The `Billable` mixin — Cashier's Billable trait, as a TypeScript mixin. Apply
- * it to a model to give that model a gateway customer, subscriptions, charges,
- * and checkout:
+ * The `Billable` mixin — apply it to a model to give that model a gateway
+ * customer, subscriptions, charges, and checkout:
  *
  *   class User extends Billable(Model) {
  *     static table = "users";

package/dist/billing/billing.config.stub

@@ -1,7 +1,7 @@
 import { env } from "@shaferllc/keel/core";
 
 /**
- * Billing configuration — a Cashier-style port covering Stripe and Paddle.
+ * Billing configuration — subscriptions and charges, covering Stripe and Paddle.
  * Published with `keel vendor:publish --tag billing-config`.
  */
 export default {

package/dist/billing/builder.d.ts

@@ -1,6 +1,6 @@
 /**
- * The fluent subscription builder — Cashier's `newSubscription(...)->create()`.
- * The `Billable` mixin hands it a small `BillableTarget` (so this file needn't
+ * The fluent subscription builder — `newSubscription(...).create()`. The
+ * `Billable` mixin hands it a small `BillableTarget` (so this file needn't
  * import the mixin, avoiding a cycle); the builder shapes the request, calls the
  * gateway, and persists a local `Subscription` synced from the result.
  *

package/dist/billing/builder.js

@@ -1,6 +1,6 @@
 /**
- * The fluent subscription builder — Cashier's `newSubscription(...)->create()`.
- * The `Billable` mixin hands it a small `BillableTarget` (so this file needn't
+ * The fluent subscription builder — `newSubscription(...).create()`. The
+ * `Billable` mixin hands it a small `BillableTarget` (so this file needn't
  * import the mixin, avoiding a cycle); the builder shapes the request, calls the
  * gateway, and persists a local `Subscription` synced from the result.
  *

package/dist/billing/provider.d.ts

@@ -1,5 +1,5 @@
 /**
- * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel Billing — subscription billing covering Stripe and Paddle, shipped as a
  * Keel package. One line in `bootstrap/providers.ts` turns it on:
  *
  *   app.register(BillingServiceProvider)

package/dist/billing/provider.js

@@ -1,5 +1,5 @@
 /**
- * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel Billing — subscription billing covering Stripe and Paddle, shipped as a
  * Keel package. One line in `bootstrap/providers.ts` turns it on:
  *
  *   app.register(BillingServiceProvider)
@@ -29,7 +29,7 @@ export class BillingServiceProvider extends PackageProvider {
         registerDefaultGateways(this.manager);
         setBilling(this.manager);
         this.app.instance(BillingManager, this.manager);
-        // Cashier targets the standard `users` billable table.
+        // Default billable table is `users`.
         this.migrations([billingMigration("users")]);
         this.publishes({ [join(here, "billing.config.stub")]: "config/billing.ts" }, "billing-config");
     }

package/dist/billing/subscription-item.d.ts

@@ -1,7 +1,6 @@
 /**
  * One line of a subscription — a single price and its quantity. A single-price
  * subscription has exactly one item; a multi-product subscription has several.
- * Mirrors Cashier's `subscription_items` table.
  */
 import { Model } from "../core/model.js";
 import type { Casts } from "../core/casts.js";

package/dist/billing/subscription-item.js

@@ -1,7 +1,6 @@
 /**
  * One line of a subscription — a single price and its quantity. A single-price
  * subscription has exactly one item; a multi-product subscription has several.
- * Mirrors Cashier's `subscription_items` table.
  */
 import { Model } from "../core/model.js";
 export class SubscriptionItem extends Model {

package/dist/core/decorators.d.ts

@@ -1,10 +1,9 @@
 /**
  * Request decorators — attach named, computed values to the current request,
- * resolved lazily and memoized for the life of that request. Inspired by
- * Fastify's `decorateRequest`, but without its footguns: you register a resolver
- * once, and Keel computes it on first access and caches it per request (keyed off
- * the Hono context via a WeakMap, so there's no shared-state leak between
- * requests and no V8 shape deopt to design around).
+ * resolved lazily and memoized for the life of that request. You register a
+ * resolver once, and Keel computes it on first access and caches it per request
+ * (keyed off the Hono context via a WeakMap, so there's no shared-state leak
+ * between requests and no V8 shape deopt to design around).
  *
  *   decorateRequest("user", async (c) => findUser(c.req.header("authorization")));
  *
@@ -18,8 +17,7 @@ import type { Context } from "hono";
 /** Resolves a decorator's value from the current request context. */
 export type RequestResolver<T = unknown> = (c: Context) => T | Promise<T>;
 /**
- * Register a request decorator. Throws if `name` is already registered — a
- * collision guard, like Fastify's.
+ * Register a request decorator. Throws if `name` is already registered.
  */
 export declare function decorateRequest<T>(name: string, resolver: RequestResolver<T>): void;
 /** Whether a request decorator has been registered. */

package/dist/core/decorators.js

@@ -1,10 +1,9 @@
 /**
  * Request decorators — attach named, computed values to the current request,
- * resolved lazily and memoized for the life of that request. Inspired by
- * Fastify's `decorateRequest`, but without its footguns: you register a resolver
- * once, and Keel computes it on first access and caches it per request (keyed off
- * the Hono context via a WeakMap, so there's no shared-state leak between
- * requests and no V8 shape deopt to design around).
+ * resolved lazily and memoized for the life of that request. You register a
+ * resolver once, and Keel computes it on first access and caches it per request
+ * (keyed off the Hono context via a WeakMap, so there's no shared-state leak
+ * between requests and no V8 shape deopt to design around).
  *
  *   decorateRequest("user", async (c) => findUser(c.req.header("authorization")));
  *
@@ -27,8 +26,7 @@ function bag(c) {
     return b;
 }
 /**
- * Register a request decorator. Throws if `name` is already registered — a
- * collision guard, like Fastify's.
+ * Register a request decorator. Throws if `name` is already registered.
  */
 export function decorateRequest(name, resolver) {
     if (resolvers.has(name)) {

package/dist/core/exceptions.d.ts

@@ -92,9 +92,8 @@ export declare class ServiceUnavailableException extends HttpException {
 }
 /**
  * Mint a reusable, coded `HttpException` subclass — the ergonomic way to define
- * app-specific errors with a stable, machine-readable `code`. Inspired by
- * `@fastify/error`. The `message` may carry `%s` placeholders, filled in order
- * from the constructor arguments.
+ * app-specific errors with a stable, machine-readable `code`. The `message` may
+ * carry `%s` placeholders, filled in order from the constructor arguments.
  *
  *   const InsufficientFunds = createError("E_FUNDS", "Balance too low: need %s", 402);
  *   throw new InsufficientFunds("$40");

package/dist/core/exceptions.js

@@ -196,9 +196,8 @@ export class ServiceUnavailableException extends HttpException {
 }
 /**
  * Mint a reusable, coded `HttpException` subclass — the ergonomic way to define
- * app-specific errors with a stable, machine-readable `code`. Inspired by
- * `@fastify/error`. The `message` may carry `%s` placeholders, filled in order
- * from the constructor arguments.
+ * app-specific errors with a stable, machine-readable `code`. The `message` may
+ * carry `%s` placeholders, filled in order from the constructor arguments.
  *
  *   const InsufficientFunds = createError("E_FUNDS", "Balance too low: need %s", 402);
  *   throw new InsufficientFunds("$40");

package/dist/core/model-query.d.ts

@@ -1,7 +1,7 @@
 /**
  * A model-aware query builder — what `Model.query()` sugar and eager loading are
  * built on. It wraps the plain `QueryBuilder`, hydrates rows into models (firing
- * `retrieved`), and adds the relationship-aware operations Eloquent has and a raw
+ * `retrieved`), and adds the relationship-aware operations a query builder lacks and a raw
  * builder can't: `with()` (nested eager loading), `withCount()`, and existence
  * filters `has()` / `whereHas()` / `doesntHave()`.
  *

package/dist/core/model-query.js

@@ -1,7 +1,7 @@
 /**
  * A model-aware query builder — what `Model.query()` sugar and eager loading are
  * built on. It wraps the plain `QueryBuilder`, hydrates rows into models (firing
- * `retrieved`), and adds the relationship-aware operations Eloquent has and a raw
+ * `retrieved`), and adds the relationship-aware operations a query builder lacks and a raw
  * builder can't: `with()` (nested eager loading), `withCount()`, and existence
  * filters `has()` / `whereHas()` / `doesntHave()`.
  *

package/dist/core/request-logger.d.ts

@@ -1,8 +1,8 @@
 /**
  * Per-request logging. `requestLogger()` middleware binds a child logger to each
  * request with a generated `reqId`, so every log line within that request
- * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
- * also log the request start and completion (method, path, status, duration).
+ * correlates — built on Keel's `Logger.child()`. It can also log the request
+ * start and completion (method, path, status, duration).
  *
  *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
  *   requestLog().info("charging card");   // anywhere in the request → carries reqId

package/dist/core/request-logger.js

@@ -1,8 +1,8 @@
 /**
  * Per-request logging. `requestLogger()` middleware binds a child logger to each
  * request with a generated `reqId`, so every log line within that request
- * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
- * also log the request start and completion (method, path, status, duration).
+ * correlates — built on Keel's `Logger.child()`. It can also log the request
+ * start and completion (method, path, status, duration).
  *
  *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
  *   requestLog().info("charging card");   // anywhere in the request → carries reqId

package/dist/core/request.js

@@ -112,7 +112,7 @@ export function html(body, status) {
 }
 export function redirect(location, status) {
     const c = maybeCtx();
-    // Koa-style `redirect("back")`: bounce to the Referer, or "/" if there isn't one.
+    // `redirect("back")`: bounce to the Referer, or "/" if there isn't one.
     if (location === "back")
         location = c?.req.header("referer") ?? "/";
     return c

package/dist/core/testing.d.ts

@@ -1,8 +1,8 @@
 /**
  * A test client for Keel apps — inject requests without a live server and assert
- * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
- * instance (which already does fetch-style request injection), adding verb
- * helpers with JSON bodies and fluent response assertions.
+ * on the response. Wraps the app's Hono instance (which already does fetch-style
+ * request injection), adding verb helpers with JSON bodies and fluent response
+ * assertions.
  *
  *   const client = await testClient(app);
  *   const res = await client.post("/users", { email: "a@b.com" });

package/dist/core/testing.js

@@ -1,8 +1,8 @@
 /**
  * A test client for Keel apps — inject requests without a live server and assert
- * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
- * instance (which already does fetch-style request injection), adding verb
- * helpers with JSON bodies and fluent response assertions.
+ * on the response. Wraps the app's Hono instance (which already does fetch-style
+ * request injection), adding verb helpers with JSON bodies and fluent response
+ * assertions.
  *
  *   const client = await testClient(app);
  *   const res = await client.post("/users", { email: "a@b.com" });

package/dist/db/d1-http.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A Keel `Connection` for Cloudflare D1 over its **HTTP API**.
+ *
+ * The D1 binding (`env.DB`) only exists inside a running Worker, which leaves an
+ * awkward hole: `keel migrate` runs on your laptop and in CI, where there is no
+ * binding — so there was no way to create your tables. This closes it. Same
+ * `Connection` interface, so migrations, models, and the query builder all work
+ * against a real D1 database from anywhere:
+ *
+ *   import { d1HttpConnection } from "@shaferllc/keel/db/d1-http";
+ *
+ *   setConnection(d1HttpConnection({
+ *     accountId: env("CLOUDFLARE_ACCOUNT_ID"),
+ *     databaseId: env("D1_DATABASE_ID"),
+ *     apiToken: env("CLOUDFLARE_API_TOKEN"),
+ *   }), "sqlite");
+ *
+ * Use the **binding** (`@shaferllc/keel/db/d1`) inside the Worker — it's a direct
+ * call with no network hop. Use this one for migrations and scripts. Both speak
+ * SQLite, so the same schema serves both.
+ *
+ * `fetch` only — no SDK, nothing Node-specific.
+ */
+import type { Connection } from "../core/database.js";
+export interface D1HttpOptions {
+    accountId: string;
+    databaseId: string;
+    /** An API token with D1 edit permission. */
+    apiToken: string;
+    /** Override the API base (for tests, or a proxy). */
+    baseUrl?: string;
+}
+/** Build a `Connection` that talks to D1 over HTTP. */
+export declare function d1HttpConnection(options: D1HttpOptions): Connection;

package/dist/db/d1-http.js

@@ -0,0 +1,61 @@
+/**
+ * A Keel `Connection` for Cloudflare D1 over its **HTTP API**.
+ *
+ * The D1 binding (`env.DB`) only exists inside a running Worker, which leaves an
+ * awkward hole: `keel migrate` runs on your laptop and in CI, where there is no
+ * binding — so there was no way to create your tables. This closes it. Same
+ * `Connection` interface, so migrations, models, and the query builder all work
+ * against a real D1 database from anywhere:
+ *
+ *   import { d1HttpConnection } from "@shaferllc/keel/db/d1-http";
+ *
+ *   setConnection(d1HttpConnection({
+ *     accountId: env("CLOUDFLARE_ACCOUNT_ID"),
+ *     databaseId: env("D1_DATABASE_ID"),
+ *     apiToken: env("CLOUDFLARE_API_TOKEN"),
+ *   }), "sqlite");
+ *
+ * Use the **binding** (`@shaferllc/keel/db/d1`) inside the Worker — it's a direct
+ * call with no network hop. Use this one for migrations and scripts. Both speak
+ * SQLite, so the same schema serves both.
+ *
+ * `fetch` only — no SDK, nothing Node-specific.
+ */
+/** Build a `Connection` that talks to D1 over HTTP. */
+export function d1HttpConnection(options) {
+    const base = options.baseUrl ?? "https://api.cloudflare.com/client/v4";
+    const url = `${base}/accounts/${options.accountId}/d1/database/${options.databaseId}/query`;
+    async function query(sql, params) {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${options.apiToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ sql, params }),
+        });
+        const payload = (await response.json());
+        if (!response.ok || !payload.success) {
+            // Cloudflare returns its errors in the body with a 200 as often as not, so
+            // the status alone is not enough to tell whether the statement ran.
+            const message = payload.errors?.map((e) => `${e.code}: ${e.message}`).join("; ") ??
+                `D1 request failed (${response.status})`;
+            throw new Error(`D1: ${message}`);
+        }
+        return payload.result;
+    }
+    return {
+        async select(sql, bindings) {
+            const result = await query(sql, bindings);
+            return result?.[0]?.results ?? [];
+        },
+        async write(sql, bindings) {
+            const result = await query(sql, bindings);
+            const meta = result?.[0]?.meta ?? {};
+            return {
+                rowsAffected: meta.changes ?? meta.rows_written ?? 0,
+                insertId: meta.last_row_id != null ? Number(meta.last_row_id) : undefined,
+            };
+        },
+    };
+}

package/dist/db/libsql.d.ts

@@ -13,14 +13,24 @@
  * The client is duck-typed — this module imports no driver, so it never bundles
  * `@libsql/client`.
  */
-import type { Connection, Row } from "../core/database.js";
+import type { Connection } from "../core/database.js";
 /** The slice of the `@libsql/client` API this adapter uses. */
 export interface LibSqlLike {
+    /**
+     * `any` rather than `unknown[]` / `Row[]` on purpose.
+     *
+     * The official client types its arguments as `InArgs` and its rows as its own
+     * `Row`, and under `strictFunctionTypes` a narrower parameter type makes the real
+     * `Client` *unassignable* to this interface — so wiring libSQL the obvious way
+     * required `client as unknown as LibSqlLike`, which is a cast a user shouldn't
+     * have to discover. Widening here keeps `libsqlConnection(createClient(…))`
+     * working with no ceremony; the values are normalized below anyway.
+     */
     execute(stmt: {
         sql: string;
-        args: unknown[];
+        args: any[];
     }): Promise<{
-        rows: Row[];
+        rows: any[];
         rowsAffected: number;
         lastInsertRowid?: bigint | number;
     }>;

package/dist/teams/models.js

@@ -56,14 +56,38 @@ export async function memberOf(userId, teamId, atLeast = "member") {
  * leave the owner out of every membership query.
  */
 export async function createTeam(name, ownerId, slug) {
-    const team = await Team.create({
-        name,
-        slug: slug ?? slugify(name),
-        owner_id: ownerId,
-    });
+    let team;
+    // Retry on the unique index, don't just look before leaping.
+    //
+    // Picking a free slug with a SELECT is a check-then-act race: two people called
+    // Ada signing up at the same moment both see "ada-s-team" is free, and one of them
+    // gets a constraint error instead of an account. The index is the only real
+    // arbiter, so the fix is to let it arbitrate and try again — not to look harder.
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const candidate = slug ?? (await uniqueSlug(slugify(name)));
+        try {
+            team = (await Team.create({ name, slug: candidate, owner_id: ownerId }));
+            break;
+        }
+        catch (error) {
+            // An explicit slug was asked for and taken: that's the caller's problem.
+            if (slug || !isUniqueViolation(error))
+                throw error;
+        }
+    }
+    if (!team)
+        throw new Error(`Could not find a free slug for "${name}".`);
     await Membership.create({ team_id: team.id, user_id: ownerId, role: "owner" });
     return team;
 }
+/** Every driver phrases it differently, and none of them agree on an error code. */
+function isUniqueViolation(error) {
+    const message = String(error?.message ?? error);
+    return (/unique/i.test(message) || // sqlite / libsql / d1
+        /duplicate key/i.test(message) || // postgres
+        /duplicate entry/i.test(message) // mysql
+    );
+}
 /**
  * Switch which team a user is acting as — **only** to a team they're actually in.
  *
@@ -77,6 +101,28 @@ export async function switchTeam(userId, teamId, userTable = "users") {
     await db(userTable).where("id", userId).update({ current_team_id: teamId });
     return true;
 }
+/**
+ * A slug nobody else has taken.
+ *
+ * `teams.slug` is unique, and personal teams are named after their owner — so two
+ * people called Ada would collide and the second one's signup would 500. Names are
+ * not unique and were never going to be; the slug has to make itself so.
+ */
+async function uniqueSlug(base) {
+    const stem = base || "team";
+    // The unique index is still the real guarantee; this just avoids the collision in
+    // the common case rather than surfacing a constraint error to someone signing up.
+    const taken = new Set((await db(Team.table).where("slug", "like", `${stem}%`).get()).map((row) => String(row.slug)));
+    if (!taken.has(stem))
+        return stem;
+    for (let n = 2; n < 1000; n++) {
+        const candidate = `${stem}-${n}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    // A thousand teams called the same thing. Fine — stop counting.
+    return `${stem}-${crypto.randomUUID().slice(0, 8)}`;
+}
 function slugify(name) {
     return name
         .toLowerCase()

package/docs/ai-manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaferllc/keel",
-  "version": "0.82.0",
+  "version": "0.83.1",
   "description": "The house framework for Node.js — a service container, providers, routing, JSX views, and a code-generating console.",
   "repo": "https://github.com/shaferllc/keel",
   "generated": "run `npm run build:ai` to regenerate",
@@ -50,7 +50,7 @@
     {
       "slug": "billing",
       "title": "Billing",
-      "summary": "Keel Billing is a subscription-billing layer — a port of Laravel Cashier — for charging customers, managing subscriptions, and reconciling gateway state through webhooks.",
+      "summary": "Keel Billing is a subscription-billing layer for charging customers, managing subscriptions, and reconciling gateway state through webhooks.",
       "path": "docs/billing.md",
       "example": null
     },
@@ -271,6 +271,13 @@
       "path": "docs/openapi.md",
       "example": null
     },
+    {
+      "slug": "orm",
+      "title": "ORM",
+      "summary": "Keel's ORM is a compact active record over the query builder: a model is a class pointed at a table, and its rows come back as typed objects with methods.",
+      "path": "docs/orm.md",
+      "example": null
+    },
     {
       "slug": "packages",
       "title": "Packages",
@@ -292,6 +299,13 @@
       "path": "docs/providers.md",
       "example": "docs/examples/providers.ts"
     },
+    {
+      "slug": "query-builder",
+      "title": "Query Builder",
+      "summary": "Keel's driver-agnostic query builder — build and run SQL by chaining methods off db(table).",
+      "path": "docs/query-builder.md",
+      "example": null
+    },
     {
       "slug": "queues",
       "title": "Queues & Jobs",
@@ -355,6 +369,13 @@
       "path": "docs/social-auth.md",
       "example": null
     },
+    {
+      "slug": "starter-kits",
+      "title": "Starter kits",
+      "summary": "",
+      "path": "docs/starter-kits.md",
+      "example": null
+    },
     {
       "slug": "static-files",
       "title": "Static Files",

package/docs/billing.md

@@ -1,9 +1,8 @@
 # Billing
 
-Keel Billing is a subscription-billing layer — a port of [Laravel
-Cashier](https://laravel.com/docs/13.x/billing) — for charging customers,
-managing subscriptions, and reconciling gateway state through webhooks. It ships
-as a Keel [package](./packages.md) and supports two gateways behind one API:
+Keel Billing is a subscription-billing layer for charging customers, managing
+subscriptions, and reconciling gateway state through webhooks. It ships as a
+Keel [package](./packages.md) and supports two gateways behind one API:
 **Stripe** and **Paddle**.
 
 It attaches to a model with a mixin. Your `User` becomes billable, gains a
@@ -221,8 +220,8 @@ resolveBillableUsing(async (customerId) => {
 The migration is gateway-neutral: `subscriptions` (with `gateway`,
 `provider_id`, `provider_status`, `provider_price`, trial/grace timestamps),
 `subscription_items`, and columns on `users` (`billing_gateway`,
-`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). Cashier
-targets the standard `users` billable table.
+`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). The default
+migration targets the standard `users` billable table.
 
 ## Testing