@porulle/core 0.11.0 → 0.14.0

package/dist/auth/auth-schema-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-schema-guard.d.ts","sourceRoot":"","sources":["../../src/auth/auth-schema-guard.ts"],"names":[],"mappings":"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"}

package/dist/auth/auth-schema-guard.js

@@ -0,0 +1,113 @@
+/**
+ * Compares Porulle's Drizzle auth tables against better-auth's canonical
+ * {@link getAuthTables} output so a dependency minor bump cannot add a column
+ * the declared schema omits.
+ */
+import { getTableColumns, getTableName } from "drizzle-orm";
+import { getAuthTables } from "better-auth/db";
+import { apiKey } from "@better-auth/api-key";
+import { organization, twoFactor, phoneNumber, jwt, bearer } from "better-auth/plugins";
+import * as authSchema from "./auth-schema.js";
+/**
+ * Every plugin {@link createAuth} can enable, not only the ones it enables by
+ * default. The shipped schema has to satisfy any configuration a merchant
+ * chooses, so the guard compares against the maximal table set: a column that
+ * only `twoFactor` needs is still a column this package must declare.
+ */
+export const AUTH_SCHEMA_GUARD_OPTIONS = {
+    plugins: [
+        organization({ roles: {} }),
+        bearer(),
+        jwt(),
+        twoFactor({ issuer: "porulle-auth-schema-guard" }),
+        apiKey(),
+        phoneNumber(),
+    ],
+    user: {
+        additionalFields: {
+            vendorId: { type: "string", required: false },
+            posOperatorPin: { type: "string", required: false },
+        },
+    },
+};
+/**
+ * Drizzle tables keyed by the SQL table name they declare, so the guard walks
+ * whatever models better-auth reports rather than a list someone has to
+ * remember to extend. A hand-maintained model list is how `jwks.alg` shipped
+ * missing while this guard passed.
+ */
+function drizzleTablesByName() {
+    const byName = new Map();
+    for (const value of Object.values(authSchema)) {
+        try {
+            byName.set(getTableName(value), value);
+        }
+        catch {
+            // Not a Drizzle table (type export, index helper) — skip.
+        }
+    }
+    return byName;
+}
+function drizzleColumnForField(table, fieldKey, fieldName) {
+    const columns = getTableColumns(table);
+    if (fieldKey in columns) {
+        return columns[fieldKey];
+    }
+    for (const column of Object.values(columns)) {
+        if (column.name === fieldName) {
+            return column;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns every mismatch between better-auth's expected auth tables and the
+ * Drizzle definitions Porulle ships. An empty array means parity holds.
+ */
+export function findAuthSchemaParityMismatches(options = AUTH_SCHEMA_GUARD_OPTIONS) {
+    const mismatches = [];
+    const authTables = getAuthTables(options);
+    const byName = drizzleTablesByName();
+    for (const [model, tableDef] of Object.entries(authTables)) {
+        if (!tableDef)
+            continue;
+        const drizzleTable = byName.get(tableDef.modelName);
+        if (!drizzleTable) {
+            mismatches.push({
+                model,
+                field: "*",
+                issue: `no drizzle table declares better-auth model "${tableDef.modelName}"`,
+            });
+            continue;
+        }
+        for (const [fieldKey, fieldAttr] of Object.entries(tableDef.fields)) {
+            const column = drizzleColumnForField(drizzleTable, fieldKey, fieldAttr.fieldName ?? fieldKey);
+            if (!column) {
+                mismatches.push({
+                    model,
+                    field: fieldKey,
+                    issue: `drizzle column missing for better-auth field "${fieldKey}"`,
+                });
+                continue;
+            }
+            const required = fieldAttr.required !== false;
+            if (required && !column.notNull) {
+                mismatches.push({
+                    model,
+                    field: fieldKey,
+                    issue: `column "${column.name}" must be NOT NULL (better-auth required)`,
+                });
+            }
+        }
+    }
+    return mismatches;
+}
+export function assertAuthSchemaParity(options = AUTH_SCHEMA_GUARD_OPTIONS) {
+    const mismatches = findAuthSchemaParityMismatches(options);
+    if (mismatches.length === 0)
+        return;
+    const detail = mismatches
+        .map((m) => `  ${m.model}.${m.field}: ${m.issue}`)
+        .join("\n");
+    throw new Error(`Porulle auth-schema.ts is out of sync with installed better-auth:\n${detail}`);
+}

package/dist/auth/auth-schema.d.ts

@@ -155,6 +155,57 @@ export declare const user: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        twoFactorEnabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "two_factor_enabled";
+            tableName: "user";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        phoneNumber: import("drizzle-orm/pg-core").PgColumn<{
+            name: "phone_number";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        phoneNumberVerified: import("drizzle-orm/pg-core").PgColumn<{
+            name: "phone_number_verified";
+            tableName: "user";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;
@@ -339,6 +390,23 @@ export declare const account: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        issuer: import("drizzle-orm/pg-core").PgColumn<{
+            name: "issuer";
+            tableName: "account";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         accountId: import("drizzle-orm/pg-core").PgColumn<{
             name: "account_id";
             tableName: "account";
@@ -1469,6 +1537,166 @@ export declare const jwks: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        alg: import("drizzle-orm/pg-core").PgColumn<{
+            name: "alg";
+            tableName: "jwks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        crv: import("drizzle-orm/pg-core").PgColumn<{
+            name: "crv";
+            tableName: "jwks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const twoFactor: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "twoFactor";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "twoFactor";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret";
+            tableName: "twoFactor";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        backupCodes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "backup_codes";
+            tableName: "twoFactor";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "twoFactor";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verified: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verified";
+            tableName: "twoFactor";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedVerificationCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_verification_count";
+            tableName: "twoFactor";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lockedUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locked_until";
+            tableName: "twoFactor";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

package/dist/auth/auth-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-schema.d.ts","sourceRoot":"","sources":["../../src/auth/auth-schema.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaf,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAclB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBlB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUvB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAarB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMf,CAAC"}
+{"version":3,"file":"auth-schema.d.ts","sourceRoot":"","sources":["../../src/auth/auth-schema.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBf,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAclB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUvB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAarB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQf,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpB,CAAC"}

package/dist/auth/auth-schema.js

@@ -1,4 +1,4 @@
-import { pgTable, text, timestamp, boolean, integer, } from "drizzle-orm/pg-core";
+import { pgTable, text, timestamp, boolean, integer, uniqueIndex, } from "drizzle-orm/pg-core";
 export const user = pgTable("user", {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
@@ -12,6 +12,12 @@ export const user = pgTable("user", {
         .notNull(),
     vendorId: text("vendor_id"),
     posOperatorPin: text("pos_operator_pin"),
+    // Contributed by the twoFactor and phoneNumber plugins. Declared
+    // unconditionally: the plugins are config-gated, but one shipped schema has
+    // to satisfy every configuration a merchant can choose.
+    twoFactorEnabled: boolean("two_factor_enabled").default(false),
+    phoneNumber: text("phone_number").unique(),
+    phoneNumberVerified: boolean("phone_number_verified").default(false),
 });
 export const session = pgTable("session", {
     id: text("id").primaryKey(),
@@ -30,6 +36,7 @@ export const session = pgTable("session", {
 });
 export const account = pgTable("account", {
     id: text("id").primaryKey(),
+    issuer: text("issuer").notNull(),
     accountId: text("account_id").notNull(),
     providerId: text("provider_id").notNull(),
     userId: text("user_id")
@@ -46,7 +53,9 @@ export const account = pgTable("account", {
     updatedAt: timestamp("updated_at")
         .$onUpdate(() => /* @__PURE__ */ new Date())
         .notNull(),
-});
+}, (table) => [
+    uniqueIndex("account_issuer_account_id_unique").on(table.issuer, table.accountId),
+]);
 export const verification = pgTable("verification", {
     id: text("id").primaryKey(),
     identifier: text("identifier").notNull(),
@@ -121,4 +130,17 @@ export const jwks = pgTable("jwks", {
     privateKey: text("private_key").notNull(),
     createdAt: timestamp("created_at").notNull(),
     expiresAt: timestamp("expires_at"),
+    alg: text("alg"),
+    crv: text("crv"),
+});
+export const twoFactor = pgTable("twoFactor", {
+    id: text("id").primaryKey(),
+    secret: text("secret").notNull(),
+    backupCodes: text("backup_codes").notNull(),
+    userId: text("user_id")
+        .notNull()
+        .references(() => user.id, { onDelete: "cascade" }),
+    verified: boolean("verified").default(false),
+    failedVerificationCount: integer("failed_verification_count").default(0),
+    lockedUntil: timestamp("locked_until"),
 });

package/dist/auth/middleware.d.ts

@@ -1,5 +1,6 @@
 import type { MiddlewareHandler } from "hono";
 import type { CommerceConfig } from "../config/types.js";
 import type { AuthInstance } from "./setup.js";
+export { DEFAULT_CUSTOMER_PERMISSIONS } from "./actor.js";
 export declare function authMiddleware(auth: AuthInstance, config: CommerceConfig): MiddlewareHandler;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/auth/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/auth/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAkC/C,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,cAAc,GACrB,iBAAiB,CA4PnB"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/auth/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAY/C,OAAO,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAK1D,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,cAAc,GACrB,iBAAiB,CAiMnB"}

package/dist/auth/middleware.js

@@ -1,28 +1,15 @@
+import { getCustomerPermissions, resolveActor } from "./actor.js";
 import { DEFAULT_ORG_ID } from "./org.js";
 import { isStrictOrgResolution } from "./strict-org-resolution.js";
-const DEFAULT_CUSTOMER_PERMISSIONS = [
-    "catalog:read",
-    "cart:create",
-    "cart:read",
-    "cart:update",
-    "orders:create",
-    "orders:read:own",
-    "customers:read:self",
-    "customers:update:self",
-];
-function getCustomerPermissions(config) {
-    return config.auth?.customerPermissions ?? [...DEFAULT_CUSTOMER_PERMISSIONS];
+function emptyToNull(value) {
+    return value == null || value === "" ? null : value;
 }
+// Exported so the storefront contract can be pinned by a test: an anonymous
+// visitor resolved by `storeResolver` gets these permissions, so dropping
+// `catalog:read` here would 401 every public storefront read.
+export { DEFAULT_CUSTOMER_PERMISSIONS } from "./actor.js";
 const LEGACY_STORE_RESOLVER_WARN_COOLDOWN_MS = 60_000;
 let lastLegacyStoreResolverWarnAt = 0;
-function resolvePermissions(session, config) {
-    const role = session.session.activeOrganizationRole;
-    if (!role) {
-        return getCustomerPermissions(config);
-    }
-    const roleConfig = config.auth?.roles?.[role];
-    return roleConfig ? roleConfig.permissions : [];
-}
 export function authMiddleware(auth, config) {
     return async (c, next) => {
         // Resolve the default org from config, falling back to deprecated constant
@@ -44,74 +31,9 @@ export function authMiddleware(auth, config) {
                 }
             }
         }
-        const session = (await auth.api.getSession({
-            headers: c.req.raw.headers,
-        }));
-        if (session) {
-            // Better Auth's session stores activeOrganizationId, but often not the role.
-            // For single-store apps (org_default), users may never call set-active,
-            // so activeOrganizationId can be null even for valid org members.
-            let role = session.session.activeOrganizationRole;
-            let orgId = session.session.activeOrganizationId;
-            // If no active org, try to resolve the user's membership in org_default.
-            // This handles the common case where the user is a member but hasn't
-            // called organization/set-active (single-store apps, seed scripts, tests).
-            if (!role && auth.api.getFullOrganization) {
-                try {
-                    const org = await auth.api.getFullOrganization({
-                        query: { organizationId: orgId ?? defaultOrgId },
-                        headers: c.req.raw.headers,
-                    });
-                    if (org?.members) {
-                        const membership = org.members.find((m) => m.userId === session.user.id);
-                        if (membership) {
-                            role = membership.role;
-                            orgId = orgId ?? defaultOrgId;
-                        }
-                    }
-                }
-                catch {
-                    // fall through — treat as customer
-                }
-            }
-            // Also try getActiveMemberRole if active org is set
-            if (!role && orgId && auth.api.getActiveMemberRole) {
-                try {
-                    const roleResult = await auth.api.getActiveMemberRole({
-                        headers: c.req.raw.headers,
-                    });
-                    role = roleResult?.role;
-                }
-                catch {
-                    // fall through — treat as customer
-                }
-            }
-            // For customers without org membership, resolve the store from the request.
-            // This enables multi-store SaaS where each storefront is a different org.
-            if (!orgId && config.auth?.storeResolver) {
-                try {
-                    const resolved = await config.auth.storeResolver(c.req.raw);
-                    if (resolved)
-                        orgId = resolved;
-                }
-                catch {
-                    // fall through — use defaultOrgId
-                }
-            }
-            const enrichedSession = {
-                ...session,
-                session: { ...session.session, activeOrganizationRole: role ?? null },
-            };
-            c.set("actor", {
-                type: "user",
-                userId: session.user.id,
-                email: session.user.email ?? null,
-                name: session.user.name ?? "User",
-                vendorId: session.user.vendorId ?? null,
-                organizationId: orgId ?? defaultOrgId,
-                role: role ?? "customer",
-                permissions: resolvePermissions(enrichedSession, config),
-            });
+        const actor = await resolveActor(c.req.raw.headers, auth, config, c.req.raw);
+        if (actor) {
+            c.set("actor", actor);
             await next();
             return;
         }
@@ -166,9 +88,11 @@ export function authMiddleware(auth, config) {
                             : null;
                     const metaOrg = typeof meta?.organizationId === "string" ? meta.organizationId : undefined;
                     const orgId = (metaOrg ?? apiKey.organizationId ?? defaultOrgId);
-                    const userId = ((typeof meta?.operatorId === "string" ? meta.operatorId : undefined)
-                        ?? apiKey.referenceId
-                        ?? "");
+                    // No operator and no reference means the key carries no user
+                    // identity. Leave it absent rather than substituting a shared
+                    // placeholder, which would make every such key look like one person.
+                    const userId = emptyToNull((typeof meta?.operatorId === "string" ? meta.operatorId : undefined) ??
+                        (typeof apiKey.referenceId === "string" ? apiKey.referenceId : undefined));
                     // Better Auth stores permissions as Record<string, string[]>
                     // (e.g. {"catalog":["read","create"]}).  Flatten to the
                     // "resource:action" string[] format the engine expects.
@@ -217,7 +141,7 @@ export function authMiddleware(auth, config) {
                         // services can scope queries correctly.
                         c.set("actor", {
                             type: "user",
-                            userId: "anonymous",
+                            userId: null,
                             email: null,
                             name: "Anonymous",
                             vendorId: null,

package/dist/auth/org.d.ts

@@ -10,14 +10,20 @@ export declare const DEFAULT_ORG_ID = "org_default";
  * config (available at boot) and services (which don't have config access).
  */
 export declare function setBootDefaultOrgId(orgId: string): void;
+/**
+ * Resolves org using an explicit config default — not ambient boot state.
+ * Use when the caller holds CommerceConfig and may lack an actor organizationId.
+ */
+export declare function resolveOrgIdForCommerce(actor: unknown, config?: CommerceConfig | null): string;
 /**
  * Extracts the organization ID from an actor.
  *
  * Resolution order:
  * 1. Actor's organizationId (set by middleware from session/API key/storeResolver)
  * 2. Explicit defaultOrgId parameter (caller override)
- * 3. Boot-time default (from config.auth.defaultOrganizationId via setBootDefaultOrgId)
- * 4. Deprecated fallback to DEFAULT_ORG_ID (will be removed)
+ * 3. Strict check — throw OrgResolutionError when enabled
+ * 4. Boot-time default (from config.auth.defaultOrganizationId via setBootDefaultOrgId)
+ * 5. Deprecated fallback to DEFAULT_ORG_ID (will be removed)
  */
 export declare function resolveOrgId(actor: unknown, defaultOrgId?: string, commerceConfig?: CommerceConfig): string;
 /**

package/dist/auth/org.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"org.d.ts","sourceRoot":"","sources":["../../src/auth/org.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAiBzD;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAS5C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,YAAY,CAAC,EAAE,MAAM,EACrB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAcR;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,OAAO,EACX,SAAS,SAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAOf"}
+{"version":3,"file":"org.d.ts","sourceRoot":"","sources":["../../src/auth/org.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAiBzD;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAS5C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEvD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,GAC7B,MAAM,CAER;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,YAAY,CAAC,EAAE,MAAM,EACrB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAcR;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,OAAO,EACX,SAAS,SAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/auth/org.js

@@ -29,14 +29,22 @@ let _bootDefaultOrgId;
 export function setBootDefaultOrgId(orgId) {
     _bootDefaultOrgId = orgId;
 }
+/**
+ * Resolves org using an explicit config default — not ambient boot state.
+ * Use when the caller holds CommerceConfig and may lack an actor organizationId.
+ */
+export function resolveOrgIdForCommerce(actor, config) {
+    return resolveOrgId(actor, config?.auth?.defaultOrganizationId, config ?? undefined);
+}
 /**
  * Extracts the organization ID from an actor.
  *
  * Resolution order:
  * 1. Actor's organizationId (set by middleware from session/API key/storeResolver)
  * 2. Explicit defaultOrgId parameter (caller override)
- * 3. Boot-time default (from config.auth.defaultOrganizationId via setBootDefaultOrgId)
- * 4. Deprecated fallback to DEFAULT_ORG_ID (will be removed)
+ * 3. Strict check — throw OrgResolutionError when enabled
+ * 4. Boot-time default (from config.auth.defaultOrganizationId via setBootDefaultOrgId)
+ * 5. Deprecated fallback to DEFAULT_ORG_ID (will be removed)
  */
 export function resolveOrgId(actor, defaultOrgId, commerceConfig) {
     if (actor != null && typeof actor === "object" && "organizationId" in actor) {
@@ -46,11 +54,11 @@ export function resolveOrgId(actor, defaultOrgId, commerceConfig) {
     }
     if (defaultOrgId)
         return defaultOrgId;
-    if (_bootDefaultOrgId)
-        return _bootDefaultOrgId;
     if (isStrictOrgResolution(commerceConfig)) {
         throw new OrgResolutionError("Organization could not be resolved: no actor organizationId, no defaultOrgId, and no configured default organization.");
     }
+    if (_bootDefaultOrgId)
+        return _bootDefaultOrgId;
     warnDeprecatedOrgDefaultFallback();
     return DEFAULT_ORG_ID;
 }

package/dist/auth/organization-guard.d.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareHandler } from "hono";
+import type { CommerceConfig } from "../config/types.js";
+import type { DrizzleDatabase } from "../kernel/database/drizzle-db.js";
+export declare function organizationGuard(db: DrizzleDatabase, config: CommerceConfig): MiddlewareHandler;
+//# sourceMappingURL=organization-guard.d.ts.map

package/dist/auth/organization-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"organization-guard.d.ts","sourceRoot":"","sources":["../../src/auth/organization-guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AA+DxE,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,eAAe,EACnB,MAAM,EAAE,cAAc,GACrB,iBAAiB,CAwFnB"}