nolo-cli 0.1.30 → 0.1.31

package/auth/server/productEntitlements.ts

@@ -1,4 +1,4 @@
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 
 export type ProductKind = "doc" | "agent" | "tool" | "license";
 export type ProductStatus = "active" | "disabled";
@@ -66,6 +66,9 @@ export type ProductEntitlementStore = {
   get: (key: string) => Promise<unknown>;
 };
 
+const getDefaultProductEntitlementStore = (): ProductEntitlementStore =>
+  getServerAuthorityStore();
+
 export const productKey = (productId: string) => `product-${productId}`;
 
 export const productPurchaseKey = (buyerId: string, productId: string) =>
@@ -87,7 +90,7 @@ const getMaybe = async <T>(
 };
 
 export const getProductRecord = async ({
-  store = serverDb,
+  store = getDefaultProductEntitlementStore(),
   productId,
 }: {
   store?: ProductEntitlementStore;
@@ -96,7 +99,7 @@ export const getProductRecord = async ({
   getMaybe<ProductRecord>(store, productKey(productId));
 
 export const getProductPriceCredits = async ({
-  store = serverDb,
+  store = getDefaultProductEntitlementStore(),
   productId,
 }: {
   store?: ProductEntitlementStore;
@@ -112,7 +115,7 @@ export const getProductPriceCredits = async ({
 };
 
 export const getActiveEntitlement = async ({
-  store = serverDb,
+  store = getDefaultProductEntitlementStore(),
   userId,
   productId,
   nowMs = Date.now(),

package/auth/server/productPurchase.ts

@@ -1,5 +1,6 @@
 import { DB_PREFIX, createTransactionKey } from "../../database/keys";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 
 import { balanceLockManager } from "./locks";
 import {
@@ -26,6 +27,13 @@ type ProductPurchaseStore = {
   ) => Promise<void>;
 };
 
+const createProductPurchaseStore = (
+  authorityStore = getServerAuthorityStore()
+): ProductPurchaseStore => ({
+  get: (key) => authorityStore.get(key),
+  batch: (ops) => writeStoreOps(authorityStore, ops),
+});
+
 export type PurchaseProductResult =
   | {
       success: true;
@@ -73,7 +81,7 @@ const isPositiveFinite = (value: unknown): value is number =>
   typeof value === "number" && Number.isFinite(value) && value > 0;
 
 export async function purchaseProduct({
-  store = serverDb,
+  store = createProductPurchaseStore(getServerAuthorityStore()),
   runtime,
   buyerId,
   productId,

package/auth/server/providerBillingDrilldown.ts

@@ -0,0 +1,47 @@
+import { buildProviderBillingDrilldown } from "../../ai/token/providerBillingDrilldown";
+import { getServerAuthorityStore } from "../../database/server/db";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+} from "./shared";
+import { canManageUsageReportAccess } from "./usageManagementAccess";
+
+const parseLimit = (value: string | null) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return 50;
+  return Math.min(Math.max(Math.floor(parsed), 1), 200);
+};
+
+export async function handleGetProviderBillingDrilldown(req: Request) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  if (!(await canManageUsageReportAccess(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  try {
+    const url = new URL(req.url);
+    const bucketId = url.searchParams.get("bucketId")?.trim();
+    if (!bucketId) {
+      return createErrorResponse("Missing bucketId", 400);
+    }
+    const drilldown = await buildProviderBillingDrilldown({
+      store: getServerAuthorityStore(),
+      bucketId,
+      limit: parseLimit(url.searchParams.get("limit")),
+    });
+    return createSuccessResponse({ success: true, drilldown });
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.startsWith("provider reconciliation bucket not found:")
+    ) {
+      return createErrorResponse("Provider reconciliation bucket not found", 404);
+    }
+    return createErrorResponse("Internal server error");
+  }
+}

package/auth/server/providerBillingHealth.ts

@@ -0,0 +1,71 @@
+import { buildProviderBillingHealthReport } from "../../ai/token/providerBillingHealthReport";
+import { getServerAuthorityStore } from "../../database/server/db";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+} from "./shared";
+import { canManageUsageReportAccess } from "./usageManagementAccess";
+
+const parseTimestamp = (value: string | null) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) {
+    const numberValue = Number(trimmed);
+    return Number.isFinite(numberValue) ? new Date(numberValue).toISOString() : null;
+  }
+  const parsed = Date.parse(trimmed);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+};
+
+const parseSinceDays = (value: string | null) => {
+  if (!value) return 7;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 7;
+  return Math.min(parsed, 3660);
+};
+
+const parseLimit = (value: string | null) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return 20;
+  return Math.min(Math.max(Math.floor(parsed), 1), 200);
+};
+
+export async function handleGetProviderBillingHealth(req: Request) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  if (!(await canManageUsageReportAccess(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  try {
+    const url = new URL(req.url);
+    const now = Date.now();
+    const until =
+      parseTimestamp(url.searchParams.get("until")) ?? new Date(now).toISOString();
+    const since =
+      parseTimestamp(url.searchParams.get("since")) ??
+      new Date(
+        Date.parse(until) -
+          parseSinceDays(url.searchParams.get("sinceDays")) * 24 * 3600_000
+      ).toISOString();
+    if (Date.parse(since) > Date.parse(until)) {
+      return createErrorResponse("Invalid provider billing health time range", 400);
+    }
+
+    const report = await buildProviderBillingHealthReport({
+      store: getServerAuthorityStore(),
+      since,
+      until,
+      limit: parseLimit(url.searchParams.get("limit")),
+    });
+
+    return createSuccessResponse({ success: true, report });
+  } catch {
+    return createErrorResponse("Internal server error");
+  }
+}

package/auth/server/providerCredentials.ts

@@ -0,0 +1,136 @@
+import { listProviderCredentialRegistryRecords } from "../../ai/token/providerCredentialRegistryList";
+import type { ProviderCredentialStatus } from "../../ai/token/providerCredentialRegistry";
+import { createProviderCredentialLifecycleEvent } from "../../ai/token/providerCredentialLifecycle";
+import { writeProviderCredentialLifecycleEvent } from "../../ai/token/providerCredentialLifecycleWriter";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { ulid } from "ulid";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+} from "./shared";
+import { canManageUsageReportAccess } from "./usageManagementAccess";
+
+const serverDb = getServerAuthorityStore();
+
+const parseStatus = (value: string | null): ProviderCredentialStatus | undefined => {
+  if (value === "active" || value === "rotating" || value === "revoked") {
+    return value;
+  }
+  return undefined;
+};
+
+const parseTimestamp = (value: string | null) => {
+  if (!value?.trim()) return undefined;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : undefined;
+};
+
+const parseBodyTimestamp = (value: unknown) => {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : undefined;
+};
+
+type ProviderCredentialLifecycleDeps = {
+  store?: Parameters<typeof writeProviderCredentialLifecycleEvent>[0]["store"];
+  canManage?: (userId?: string | null) => Promise<boolean>;
+  now?: () => string;
+  createEventId?: () => string;
+};
+
+export async function handleListProviderCredentials(req: Request) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  if (!(await canManageUsageReportAccess(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  try {
+    const url = new URL(req.url);
+    const result = await listProviderCredentialRegistryRecords({
+      store: serverDb,
+      provider: url.searchParams.get("provider") ?? undefined,
+      status: parseStatus(url.searchParams.get("status")),
+      at: parseTimestamp(url.searchParams.get("at")),
+    });
+
+    return createSuccessResponse({ success: true, ...result });
+  } catch {
+    return createErrorResponse("Internal server error");
+  }
+}
+
+export async function handleUpdateProviderCredentialLifecycle(
+  req: Request,
+  deps: ProviderCredentialLifecycleDeps = {}
+) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  const canManage = deps.canManage ?? canManageUsageReportAccess;
+  if (!(await canManage(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = (await req.json()) as Record<string, unknown>;
+  } catch {
+    return createErrorResponse("Invalid JSON body", 400);
+  }
+
+  const credentialId =
+    typeof body.credentialId === "string" ? body.credentialId.trim() : "";
+  if (!credentialId) {
+    return createErrorResponse("credentialId is required", 400);
+  }
+
+  const status = parseStatus(
+    typeof body.status === "string" ? body.status : null
+  );
+  if (!status) {
+    return createErrorResponse("status must be active, rotating, or revoked", 400);
+  }
+
+  const now = deps.now?.() ?? new Date().toISOString();
+  const effectiveAt = parseBodyTimestamp(body.effectiveAt) ?? now;
+  const event = createProviderCredentialLifecycleEvent({
+    credentialId,
+    eventId:
+      typeof body.eventId === "string" && body.eventId.trim()
+        ? body.eventId.trim()
+        : deps.createEventId?.() ?? `evt_${ulid()}`,
+    status,
+    effectiveAt,
+    createdAt: now,
+    reason: typeof body.reason === "string" ? body.reason : undefined,
+    actorId: actionUserId,
+  });
+
+  try {
+    const result = await writeProviderCredentialLifecycleEvent({
+      store: deps.store ?? serverDb,
+      event,
+    });
+    return createSuccessResponse({
+      success: true,
+      key: result.key,
+      event: {
+        credentialId: event.credentialId,
+        eventId: event.eventId,
+        status: event.status,
+        effectiveAt: event.effectiveAt,
+        createdAt: event.createdAt,
+        actorId: event.actorId,
+      },
+    });
+  } catch {
+    return createErrorResponse("Internal server error");
+  }
+}

package/auth/server/recharge.ts

@@ -1,6 +1,7 @@
 // auth/server/recharge.ts
 import { ulid } from "ulid";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 import { createTransactionKey } from "../../database/keys";
 import { balanceLockManager } from "./locks";
 import { withRetry } from "./utils";
@@ -12,7 +13,6 @@ import {
   prepareLedgerTransactionAppend,
   userAvailableCreditsAccountId,
 } from "./ledger";
-
 const logger = pino({ name: "recharge" });
 
 interface RechargeResult {
@@ -59,6 +59,12 @@ export async function rechargeUserBalance(
   txId: string = ulid()
 ): Promise<RechargeResult> {
   const lock = balanceLockManager.getLock(toUserId);
+  const store = getServerAuthorityStore();
+  const ledgerStore = {
+    get: (key: string) => store.get(key),
+    batch: (ops: Array<{ type: "put"; key: string; value: unknown }>) =>
+      writeStoreOps(store, ops),
+  };
 
   return await lock.runExclusive(async () => {
     try {
@@ -73,7 +79,7 @@ export async function rechargeUserBalance(
       let existingTx = null;
 
       try {
-        existingTx = await serverDb.get(txIndexKey);
+        existingTx = await store.get(txIndexKey);
       } catch (err) {
         if (!(err instanceof Error && "notFound" in err)) {
           throw err;
@@ -93,7 +99,7 @@ export async function rechargeUserBalance(
       let userData: UserData | null = null;
 
       try {
-        userData = await serverDb.get(userKey);
+        userData = await store.get(userKey);
         logger.debug({ toUserId, userData, userKey }, "Retrieved user data");
       } catch (err) {
         if (err instanceof Error && "notFound" in err) {
@@ -121,7 +127,7 @@ export async function rechargeUserBalance(
       const currentBalance = userData.balance;
       const now = Date.now();
       const ledgerAppend = await prepareLedgerTransactionAppend({
-        store: serverDb,
+        store: ledgerStore,
         type: "recharge",
         reason,
         idempotencyKey: txId,
@@ -181,7 +187,7 @@ export async function rechargeUserBalance(
 
       await withRetry(
         async () => {
-          await serverDb.batch([
+          await writeStoreOps(store, [
             ...ledgerAppend.operations,
             {
               type: "put",
@@ -239,7 +245,7 @@ export async function rechargeUserBalance(
             let txRecord: TransactionRecord | null = null;
 
             try {
-              txRecord = await serverDb.get(txKey);
+              txRecord = await store.get(txKey);
             } catch (err) {
               if (!(err instanceof Error && "notFound" in err)) {
                 throw err;
@@ -247,7 +253,7 @@ export async function rechargeUserBalance(
             }
 
             if (txRecord) {
-              await serverDb.put(txKey, {
+              await store.put(txKey, {
                 ...txRecord,
                 status: "failed",
               });

package/auth/server/revokeSessions.ts

@@ -1,6 +1,6 @@
 import { verifyToken } from "../token";
 import { getNextSessionTokenVersion } from "../sessionTokenVersion";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { DB_PREFIX } from "../../database/keys";
 
 import {
@@ -10,6 +10,7 @@ import {
 } from "./shared";
 
 export async function handleRevokeSessions(req: any) {
+  const store = getServerAuthorityStore();
   if (req.method === "OPTIONS") {
     return handleOptionsRequest();
   }
@@ -29,7 +30,7 @@ export async function handleRevokeSessions(req: any) {
   }
 
   const userKey = `${DB_PREFIX.USER}${authedUserId}`;
-  const user = await serverDb.get(userKey);
+  const user = await store.get(userKey);
   if (!user?.publicKey) {
     return createErrorResponse("User not found", 404);
   }
@@ -46,7 +47,7 @@ export async function handleRevokeSessions(req: any) {
   }
 
   const nextTokenVersion = getNextSessionTokenVersion(user);
-  await serverDb.put(userKey, {
+  await store.put(userKey, {
     ...user,
     tokenVersion: nextTokenVersion,
     tokenVersionUpdatedAt: Date.now(),

package/auth/server/route.ts

@@ -14,6 +14,7 @@ import { handleRevokeSessions } from "./revokeSessions";
 import { handleTransferUser } from "./transfer";
 import { handleDisableUser } from "./disable";
 import { handleEnableUser } from "./enable";
+import { handleUpdateUserAdminPermissions } from "./adminPermissions";
 import { handleSendEmail } from "./sendEmail";
 import {
   handleGetEmailPreferences,
@@ -29,6 +30,19 @@ import {
   handleUpdateEmailRuntimeConfig,
 } from "./emailRuntimeConfig";
 import { handleGetRechargeHistory } from "./getRechargeHistory";
+import { handleAdminUsageReport } from "./adminUsageReport";
+import { handleGetUsageReport } from "./usageReport";
+import { handleGetProviderBillingHealth } from "./providerBillingHealth";
+import { handleGetProviderBillingDrilldown } from "./providerBillingDrilldown";
+import {
+  handleListProviderCredentials,
+  handleUpdateProviderCredentialLifecycle,
+} from "./providerCredentials";
+import {
+  handleCreateBillingAdminAuditEvent,
+  handleGetBillingAnomalyDrilldown,
+  handleUpdateBillingAnomalyLifecycle,
+} from "./billingAnomalies";
 
 const routeHandlers = [
   {
@@ -86,6 +100,14 @@ const routeHandlers = [
         "send-email",
         "email-preferences",
         "email-report",
+        "usage-report",
+        "provider-billing-health",
+        "provider-billing-drilldown",
+        "provider-credentials",
+        "provider-credentials/lifecycle",
+        "billing-anomalies/lifecycle",
+        "billing-anomalies/drilldown",
+        "billing-anomalies/audit",
         "email-retry",
         "email-replay-failures",
         "email-config",
@@ -125,6 +147,16 @@ const routeHandlers = [
     handler: (req, params: RouteParams) =>
       handleEnableUser(req, params.userId!),
   },
+  {
+    ...authRoutes.users.adminPermissions,
+    match: (path: string) => {
+      const matcher = createPathMatcher(authRoutes.users.adminPermissions.path);
+      const match = path.match(matcher);
+      return match ? { userId: match[1] } : false;
+    },
+    handler: (req, params: RouteParams) =>
+      handleUpdateUserAdminPermissions(req, params.userId!),
+  },
   {
     ...authRoutes.users.sendEmail,
     match: (path: string) => path === authRoutes.users.sendEmail.path,
@@ -145,6 +177,51 @@ const routeHandlers = [
     match: (path: string) => path === authRoutes.users.emailReport.path,
     handler: (req) => handleGetEmailReport(req),
   },
+  {
+    ...authRoutes.users.usageReport,
+    match: (path: string) => path === authRoutes.users.usageReport.path,
+    handler: (req) => {
+      const url = new URL(req.url);
+      return url.searchParams.has("sinceMs") || url.searchParams.has("untilMs")
+        ? handleAdminUsageReport(req)
+        : handleGetUsageReport(req);
+    },
+  },
+  {
+    ...authRoutes.users.providerBillingHealth,
+    match: (path: string) => path === authRoutes.users.providerBillingHealth.path,
+    handler: (req) => handleGetProviderBillingHealth(req),
+  },
+  {
+    ...authRoutes.users.providerBillingDrilldown,
+    match: (path: string) => path === authRoutes.users.providerBillingDrilldown.path,
+    handler: (req) => handleGetProviderBillingDrilldown(req),
+  },
+  {
+    ...authRoutes.users.providerCredentials,
+    match: (path: string) => path === authRoutes.users.providerCredentials.path,
+    handler: (req) => handleListProviderCredentials(req),
+  },
+  {
+    ...authRoutes.users.providerCredentialLifecycle,
+    match: (path: string) => path === authRoutes.users.providerCredentialLifecycle.path,
+    handler: (req) => handleUpdateProviderCredentialLifecycle(req),
+  },
+  {
+    ...authRoutes.users.billingAnomalyLifecycle,
+    match: (path: string) => path === authRoutes.users.billingAnomalyLifecycle.path,
+    handler: (req) => handleUpdateBillingAnomalyLifecycle(req),
+  },
+  {
+    ...authRoutes.users.billingAnomalyDrilldown,
+    match: (path: string) => path === authRoutes.users.billingAnomalyDrilldown.path,
+    handler: (req) => handleGetBillingAnomalyDrilldown(req),
+  },
+  {
+    ...authRoutes.users.billingAnomalyAudit,
+    match: (path: string) => path === authRoutes.users.billingAnomalyAudit.path,
+    handler: (req) => handleCreateBillingAdminAuditEvent(req),
+  },
   {
     ...authRoutes.users.emailRetryRun,
     match: (path: string) => path === authRoutes.users.emailRetryRun.path,

package/auth/server/sendEmail.ts

@@ -1,5 +1,5 @@
 import { DB_PREFIX } from "../../database/keys";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import {
   checkAdminPermission,
   createErrorResponse,
@@ -46,6 +46,7 @@ export async function handleSendEmail(req: Request) {
   if (permissionError) return permissionError;
 
   try {
+    const store = getServerAuthorityStore();
     const broadcastConfig = getBroadcastConfig();
     const { subject, body, isHtml, userIds, tag } = ((req as any).body ||
       {}) as SendEmailRequest;
@@ -64,7 +65,7 @@ export async function handleSendEmail(req: Request) {
       const uniqueIds = [...new Set(userIds.map((id: string) => id.trim()).filter(Boolean))];
       for (const id of uniqueIds) {
         try {
-          const userData = await serverDb.get(prefix + id);
+          const userData = await store.get(prefix + id);
           const decision = canSendEmailToUser(userData, emailTag, now);
           if (decision.allowed) {
             recipients.push({ email: String(userData.email), id });
@@ -76,7 +77,7 @@ export async function handleSendEmail(req: Request) {
         }
       }
     } else {
-      const iter = serverDb.iterator({
+      const iter = store.iterator({
         gt: prefix,
         lt: prefix + "\xFF",
       });
@@ -96,7 +97,7 @@ export async function handleSendEmail(req: Request) {
           }
         }
       } finally {
-        await iter.close();
+        await (iter as any).close?.();
       }
     }
 

package/auth/server/signup.ts

@@ -2,7 +2,8 @@
 // 注册接口（按 IP 配额限制，默认：同一 IP 每日仅允许注册 1 个；支持灵活扩展周/月窗口）
 
 import i18nServer from "../../app/i18n/i18n.server";
-import serverDb from "../../database/server/db.js";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 import { signMessage } from "../../core/crypto";
 import { generateUserIdV1 } from "../../core/generateMainKey";
 import {
@@ -30,6 +31,7 @@ import {
 const logger = pino({ name: "signup" });
 const signupLocks = new Map<string, Mutex>();
 const signupIpLocks = new Map<string, Mutex>();
+const getSignupStore = () => getServerAuthorityStore();
 
 function getSignupLock(userId: string): Mutex {
   let lock = signupLocks.get(userId);
@@ -85,6 +87,7 @@ function getDayKeysBackwards(days: number): string[] {
 }
 
 async function getIpDayCount(ip: string, dayKey: string): Promise<number> {
+  const serverDb = getSignupStore();
   try {
     const val = await serverDb.get(ABUSE_PREFIX.byIpDay(ip, dayKey));
     const n = Number(val);
@@ -124,6 +127,7 @@ async function checkIpQuotas(ip: string, t: any) {
 }
 
 async function recordIpRegistration(ip: string) {
+  const serverDb = getSignupStore();
   const today = getDayKey();
   const key = ABUSE_PREFIX.byIpDay(ip, today);
   let count = 0;
@@ -168,6 +172,7 @@ function generateUserId(publicKey: string, username: string, locale: string) {
 }
 
 async function checkUserExists(userId: string, t: any) {
+  const serverDb = getSignupStore();
   try {
     const existingUser = await serverDb.get(DB_PREFIX.USER + userId);
     if (existingUser) {
@@ -229,7 +234,8 @@ async function saveUserDataToDb(
   userSettings: any,
   userProfile: any
 ) {
-  await serverDb.batch([
+  const serverDb = getSignupStore();
+  await writeStoreOps(serverDb, [
     { type: "put", key: DB_PREFIX.USER + userId, value: userData },
     { type: "put", key: createUserKey.settings(userId), value: userSettings },
     { type: "put", key: createUserKey.profile(userId), value: userProfile },
@@ -237,7 +243,8 @@ async function saveUserDataToDb(
 }
 
 async function rollbackUserDataFromDb(userId: string) {
-  await serverDb.batch([
+  const serverDb = getSignupStore();
+  await writeStoreOps(serverDb, [
     { type: "del", key: DB_PREFIX.USER + userId },
     { type: "del", key: createUserKey.settings(userId) },
     { type: "del", key: createUserKey.profile(userId) },