@saasicat/ui-vue 0.26.0 → 0.27.0

package/src/client/resources/promo-codes.resource.ts

@@ -0,0 +1,63 @@
+// Promo codes — the discount codes an operator hands out.
+//
+// Not to be confused with `promotions.resource`, which is a different
+// endpoint (`catalog/promotions`), a different table and a different job: a
+// promotion is a price rule attached to a plan or bundle in the catalogue, a
+// promo code is a string a customer types at checkout. The plan's roster
+// called both "promos"; the sources call them two things, and so do we.
+//
+// The list does not page. `AdminResourcesPort` answers a bare array here, so
+// this is a plain operation over `filterQueryString` rather than a
+// `defineListOp` — a paginated descriptor would offer a paginator over a
+// server that ignores it.
+
+import type { PromoCodeRecord } from '@saasicat/types';
+
+import { defineResource, type ResourceContext } from './define-resource.js';
+import { filterQueryString } from './list-resource.js';
+import { requestJson } from './resource-request.js';
+
+/** What the promo list can be narrowed by, including its "all" state. */
+export interface PromoCodesFilter {
+    search?: string;
+    status?: string | null;
+}
+
+function promoCodesUrl(ctx: ResourceContext): string {
+    return `${ctx.apiBase}/promo-codes`;
+}
+
+export const promoCodesResource = defineResource('promoCodes', {
+    list: async (http, ctx, filter: PromoCodesFilter = {}): Promise<PromoCodeRecord[]> =>
+        (await requestJson<PromoCodeRecord[]>(
+            http,
+            `${promoCodesUrl(ctx)}${filterQueryString({
+                search: filter.search,
+                status: filter.status,
+            })}`,
+        )) ?? [],
+
+    /**
+     * Returns nothing, matching `createAdminResourceClient.createPromo`.
+     *
+     * The endpoint does answer with the created record, but the page it feeds
+     * reloads the list rather than reading it, and promising a body a caller
+     * would then have to trust is a wider contract than anything holds today.
+     */
+    create: async (http, ctx, payload: unknown): Promise<void> => {
+        await requestJson(http, promoCodesUrl(ctx), { method: 'POST', body: payload });
+    },
+
+    update: async (http, ctx, id: string, payload: unknown): Promise<void> => {
+        await requestJson(http, `${promoCodesUrl(ctx)}/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: payload,
+        });
+    },
+
+    remove: async (http, ctx, id: string): Promise<void> => {
+        await requestJson(http, `${promoCodesUrl(ctx)}/${encodeURIComponent(id)}`, {
+            method: 'DELETE',
+        });
+    },
+});

package/src/client/resources/promotions.resource.ts

@@ -0,0 +1,44 @@
+// Catalogue promotions — price rules attached to a plan, bundle or offer.
+//
+// A sibling of `promo-codes.resource` in name only; see the note there for
+// why the two are separate. This one lives under `catalog/`, is scoped to a
+// project, and never reaches a customer directly.
+
+import type { CreatePromotionData, PromotionRow, UpdatePromotionData } from '@saasicat/types';
+
+import { defineResource, type ResourceContext } from './define-resource.js';
+import { requestJson, requestJsonBody } from './resource-request.js';
+
+function promotionsUrl(ctx: ResourceContext): string {
+    return `${ctx.apiBase}/catalog/promotions`;
+}
+
+export const promotionsResource = defineResource(
+    'promotions',
+    {
+        list: async (http, ctx): Promise<PromotionRow[]> =>
+            (await requestJson<PromotionRow[]>(
+                http,
+                `${promotionsUrl(ctx)}?projectKey=${encodeURIComponent(ctx.projectKey)}`,
+            )) ?? [],
+
+        create: (http, ctx, data: CreatePromotionData): Promise<PromotionRow> =>
+            requestJsonBody<PromotionRow>(http, promotionsUrl(ctx), 'Create returned no body', {
+                method: 'POST',
+                body: data,
+            }),
+
+        update: (http, ctx, id: string, data: UpdatePromotionData): Promise<PromotionRow> =>
+            requestJsonBody<PromotionRow>(
+                http,
+                `${promotionsUrl(ctx)}/${id}`,
+                'Update returned no body',
+                { method: 'PATCH', body: data },
+            ),
+
+        remove: async (http, ctx, id: string): Promise<void> => {
+            await requestJson(http, `${promotionsUrl(ctx)}/${id}`, { method: 'DELETE' });
+        },
+    },
+    { projectScoped: true },
+);

package/src/client/resources/subscriptions.resource.ts

@@ -0,0 +1,19 @@
+// The subscription list.
+//
+// One operation and no filter, because that is the endpoint: the controller
+// takes no query and answers every subscription it can see. `SubscriptionsPage`
+// filters and sorts the rows it was given, in the browser.
+
+import type { AdminSubscriptionListRow } from '@saasicat/types';
+
+import { defineResource, type ResourceContext } from './define-resource.js';
+import { requestJson } from './resource-request.js';
+
+function subscriptionsUrl(ctx: ResourceContext): string {
+    return `${ctx.apiBase}/subscriptions`;
+}
+
+export const subscriptionsResource = defineResource('subscriptions', {
+    list: async (http, ctx): Promise<AdminSubscriptionListRow[]> =>
+        (await requestJson<AdminSubscriptionListRow[]>(http, subscriptionsUrl(ctx))) ?? [],
+});

package/src/client/resources/tenants.resource.ts

@@ -1,9 +1,4 @@
-// The tenant list.
-//
-// One operation, deliberately: the list `useTenants` requests today. Tenant
-// detail, suspend and reactivate still live in `createAdminResourceClient` and
-// move here with the page that calls them — a descriptor nothing calls has
-// nothing keeping it honest.
+// The tenant list, one tenant, and the two states an operator can put it in.
 //
 // The request pages; the controller does not. `AdminResourcesPort.listTenants`
 // takes `status`/`plan`/`search` and answers with a bare array — no `page`, no
@@ -13,15 +8,46 @@
 // has been sending, and reproducing it is the point: what the server does with
 // the parameters is the server's to change, and a descriptor that quietly sent
 // less would be a different request wearing the same name.
+//
+// `detail`, `suspend` and `reactivate` mirror `createAdminResourceClient`,
+// which is what `TenantDetailPage` receives them through today. Slugs are
+// encoded on the way into the path there, so they are encoded here.
 
-import type { TenantDto, TenantListFilter } from '@saasicat/types';
+import type { AdminTenantDetail, TenantDto, TenantListFilter } from '@saasicat/types';
 
-import { defineResource } from './define-resource.js';
+import { defineResource, type ResourceContext } from './define-resource.js';
 import { defineListOp, type ListFilterOf } from './list-resource.js';
+import { requestJson } from './resource-request.js';
 
 /** What the tenants list can be narrowed by. The page number is not a filter. */
 export type TenantsListFilter = ListFilterOf<TenantListFilter>;
 
+function tenantsUrl(ctx: ResourceContext): string {
+    return `${ctx.apiBase}/tenants`;
+}
+
+function tenantUrl(ctx: ResourceContext, slug: string): string {
+    return `${tenantsUrl(ctx)}/${encodeURIComponent(slug)}`;
+}
+
 export const tenantsResource = defineResource('tenants', {
-    list: defineListOp<TenantDto, TenantsListFilter>((ctx) => `${ctx.apiBase}/tenants`),
+    list: defineListOp<TenantDto, TenantsListFilter>((ctx) => tenantsUrl(ctx)),
+
+    detail: async (http, ctx, slug: string): Promise<AdminTenantDetail | null> =>
+        requestJson<AdminTenantDetail>(http, tenantUrl(ctx, slug)),
+
+    /**
+     * Suspends a tenant. The reason is recorded on the audit trail, so it is a
+     * required argument rather than an option with a default.
+     */
+    suspend: async (http, ctx, slug: string, reason: string): Promise<void> => {
+        await requestJson(http, `${tenantUrl(ctx, slug)}/suspend`, {
+            method: 'POST',
+            body: { reason },
+        });
+    },
+
+    reactivate: async (http, ctx, slug: string): Promise<void> => {
+        await requestJson(http, `${tenantUrl(ctx, slug)}/reactivate`, { method: 'POST' });
+    },
 });

package/src/client/resources/users.resource.ts

@@ -0,0 +1,31 @@
+// The platform user list.
+//
+// Unpaginated, like the promo list and unlike the tenant list: the controller
+// answers a bare array filtered by `q` and `tenant`. So this is a plain
+// operation over `filterQueryString` rather than a `defineListOp` — see the
+// note on `promo-codes.resource`.
+
+import type { AdminUserListFilter, AdminUserListRow } from '@saasicat/types';
+
+import { defineResource, type ResourceContext } from './define-resource.js';
+import { filterQueryString } from './list-resource.js';
+import { requestJson } from './resource-request.js';
+
+function usersUrl(ctx: ResourceContext): string {
+    return `${ctx.apiBase}/users`;
+}
+
+export const usersResource = defineResource('users', {
+    /**
+     * `q` searches name and mail, `tenant` narrows to one tenant's members.
+     *
+     * Both are dropped when empty rather than sent as `q=` — see
+     * `isSentInQuery`; an empty search that reached the server would filter
+     * every row away on an endpoint that treats the parameter as a substring.
+     */
+    list: async (http, ctx, filter: AdminUserListFilter = {}): Promise<AdminUserListRow[]> =>
+        (await requestJson<AdminUserListRow[]>(
+            http,
+            `${usersUrl(ctx)}${filterQueryString({ q: filter.q, tenant: filter.tenant })}`,
+        )) ?? [],
+});

package/src/pages-standard/SuperAdminSetupWizard.vue

@@ -151,6 +151,7 @@
 </template>
 
 <script setup lang="ts">
+import { attachCause } from '../client/attach-cause.js';
 import { computed, reactive, ref } from 'vue';
 import { SETUP_ERROR_CODES, type SetupConfirmMfaResponse, type SetupResult } from '@saasicat/types';
 
@@ -237,10 +238,12 @@ async function postJson<T>(path: string, body: unknown): Promise<T> {
         if (err instanceof HttpJsonError) {
             // The message is translated for the user; `cause` keeps the status
             // and the machine-readable code reachable for anything upstream.
-            throw new Error(
-                (err.code && errorByCode.value[err.code]) ||
-                    formatMessage(msg.value.setup.errorHttp, { status: err.status }),
-                { cause: err },
+            throw attachCause(
+                new Error(
+                    (err.code && errorByCode.value[err.code]) ||
+                        formatMessage(msg.value.setup.errorHttp, { status: err.status }),
+                ),
+                err,
             );
         }
         throw err;