@wssto2/vue-core 0.5.3 → 0.6.0

package/dist/identity/index.d.ts

@@ -16,3 +16,10 @@ export { default as SignInAsButton } from "./SignInAsButton.vue";
 export { isSessionEnded, lockedUntil, returnToOwnAccount, signIn, signInAs } from "./signIn";
 export { parseIdentityUser } from "./user";
 export type { IdentityUser } from "./user";
+export { serviceAccountsFeature } from "./serviceaccounts/feature";
+export type { ServiceAccountsFeatureOptions } from "./serviceaccounts/feature";
+export type { ServiceAccountTenants } from "./serviceaccounts/context";
+export { serviceAccountsRoutes } from "./serviceaccounts/routes";
+export type { ServiceAccountsRoutes } from "./serviceaccounts/routes";
+export type { AccountTenant, ApiKey, ApiKeyList, CreatedApiKey, ServiceAccount, ServiceAccountList } from "../modules/serviceaccount/entities";
+export { serviceaccountRoutes } from "../modules/serviceaccount/routes";

package/dist/identity/index.js

@@ -1,19 +1,23 @@
-import { _ as t, h as n, j as a, i, k as o, d as r, l as d, m as u, n as f, r as l, s as p, o as y, q as A, f as c } from "../index-Ok29ucE3.js";
-import { _ as I } from "../ActionRow.vue_vue_type_script_setup_true_lang-Bv-APkGf.js";
+import { _ as t, k as a, l as o, i as n, m as i, d as r, n as u, o as c, q as d, r as A, t as p, s as R, v as f, w as l, x as m, g as y } from "../index-Cmj9iZmT.js";
+import { _ as v } from "../ActionRow.vue_vue_type_script_setup_true_lang-D8NCXX4p.js";
+import { s as I } from "../routes-CVckt7Pj.js";
 export {
-  I as ActionRow,
+  v as ActionRow,
   t as SignInAsButton,
-  n as identityFeature,
-  a as identityPlatform,
-  i as identityRoutes,
-  o as identitySessionAdapter,
+  a as identityFeature,
+  o as identityPlatform,
+  n as identityRoutes,
+  i as identitySessionAdapter,
   r as isSessionEnded,
-  d as lockedUntil,
-  u as parseIdentityUser,
-  f as profileRoutes,
-  l as returnToOwnAccount,
-  p as signIn,
-  y as signInAs,
-  A as usersFeature,
-  c as usersRoutes
+  u as lockedUntil,
+  c as parseIdentityUser,
+  d as profileRoutes,
+  A as returnToOwnAccount,
+  p as serviceAccountsFeature,
+  R as serviceAccountsRoutes,
+  I as serviceaccountRoutes,
+  f as signIn,
+  l as signInAs,
+  m as usersFeature,
+  y as usersRoutes
 };

package/dist/identity/serviceaccounts/ApiKeysPanel.vue.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceAccount } from "../../modules/serviceaccount/entities";
+/**
+ * *API keys*: the keys a service account signs in with: name, the start of the key, who made it and when, last use, expiry, with *New API
+ * key* (`iam.serviceaccount:manage`) and *Revoke* (`iam.serviceaccount:revoke`). Only the key's fingerprint is stored: a new key's secret is
+ * shown once (`CreatedApiKeyDialog`) and never again; to replace one, make a new key, move the system over, then revoke the old.
+ */
+type __VLS_Props = {
+    account: ServiceAccount;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    reload: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    changed: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChanged?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/CreatedApiKeyDialog.vue.d.ts

@@ -0,0 +1,53 @@
+import type { CreatedApiKey, ServiceAccount } from "../../modules/serviceaccount/entities";
+/**
+ * *The API key is created*: the secret, shown once, with *Copy* and the plain fact that it will not be shown again. It lives only in
+ * this sheet's state and is dropped when the sheet closes; only the primary button closes it, so a stray tap outside does not lose
+ * what nothing can bring back.
+ */
+type __VLS_Props = {
+    account: ServiceAccount;
+};
+declare function show(next: CreatedApiKey): void;
+declare function copySecret(): Promise<void>;
+declare function done(): void;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    show: typeof show;
+    done: typeof done;
+    copySecret: typeof copySecret;
+    created: import("vue").Ref<{
+        key: {
+            id: number;
+            name: string;
+            prefix: string;
+            created_by: {
+                id: number;
+                name: string;
+            };
+            created_at: string;
+            last_used_at: string | null;
+            expires_at: string | null;
+            revoked_at: string | null;
+        };
+        secret: string;
+    } | null, CreatedApiKey | {
+        key: {
+            id: number;
+            name: string;
+            prefix: string;
+            created_by: {
+                id: number;
+                name: string;
+            };
+            created_at: string;
+            last_used_at: string | null;
+            expires_at: string | null;
+            revoked_at: string | null;
+        };
+        secret: string;
+    } | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/NewApiKeyDialog.vue.d.ts

@@ -0,0 +1,24 @@
+import type { CreatedApiKey, ServiceAccount } from "../../modules/serviceaccount/entities";
+/**
+ * *New API key*: a name (where the key is used) and an optional expiry. The key is made on the server and its secret comes back once,
+ * which the page then shows in `CreatedApiKeyDialog`.
+ */
+type __VLS_Props = {
+    account: ServiceAccount;
+};
+type Draft = {
+    name: string;
+    expires: string | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    show: () => void;
+    form: import("../../form").Form<Draft, {
+        name: string;
+        expires_at?: string | null | undefined;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    created: (created: CreatedApiKey) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCreated?: ((created: CreatedApiKey) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/ServiceAccountDialog.vue.d.ts

@@ -0,0 +1,22 @@
+import type { ServiceAccount } from "../../modules/serviceaccount/entities";
+type Draft = {
+    name: string;
+    description: string;
+    tenant_id: number | null;
+    owner_id: number | null;
+};
+declare function show(row?: ServiceAccount): void;
+declare const _default: import("vue").DefineComponent<{}, {
+    show: typeof show;
+    form: import("../../form").Form<Draft, {
+        name: string;
+        description: string;
+        owner_id: number;
+        tenant_id?: number | null | undefined;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    saved: (account: ServiceAccount) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onSaved?: ((account: ServiceAccount) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/ServiceAccountRecord.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/ServiceAccountsList.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/serviceaccounts/access.d.ts

@@ -0,0 +1,4 @@
+import type { Permission } from "../../platform";
+export declare const VIEW_ACCOUNTS: Permission;
+export declare const MANAGE_ACCOUNTS: Permission;
+export declare const REVOKE_KEYS: Permission;

package/dist/identity/serviceaccounts/api.d.ts

@@ -0,0 +1,27 @@
+import type { HttpClient } from "../../client";
+import type { ServiceAccount, ApiKey, CreatedApiKey } from "../../modules/serviceaccount/entities";
+import type { KeyRequest, SaveInput } from "../../modules/serviceaccount/schemas";
+type Options = {
+    readonly signal?: AbortSignal;
+};
+/** go-core's service account routes as calls; `data` of each answer already read. A change takes the `Idempotency-Key` of its attempt. */
+export declare function createServiceAccountsApi(http: HttpClient): {
+    list: (options?: Options) => Promise<readonly ServiceAccount[]>;
+    show: (id: number, options?: Options) => Promise<ServiceAccount>;
+    create: (input: SaveInput, idempotencyKey: string) => Promise<ServiceAccount>;
+    update: (id: number, input: SaveInput, idempotencyKey: string) => Promise<ServiceAccount>;
+    deactivate: (id: number) => Promise<ServiceAccount>;
+    keys: (id: number, options?: Options) => Promise<readonly ApiKey[]>;
+    /** The secret is in the answer, and only there. */
+    createKey: (id: number, input: KeyRequest, idempotencyKey: string) => Promise<CreatedApiKey>;
+    revokeKey: (id: number, keyID: number) => Promise<void>;
+    /** The people who can answer for an account: the active ones of the users list (its largest page). */
+    people: (options?: Options) => Promise<readonly {
+        readonly id: number;
+        readonly name: string;
+    }[]>;
+};
+export type ServiceAccountsApi = ReturnType<typeof createServiceAccountsApi>;
+/** The calls, over the platform's client; call it in `setup`. */
+export declare const useServiceAccountsApi: () => ServiceAccountsApi;
+export {};

package/dist/identity/serviceaccounts/context.d.ts

@@ -0,0 +1,14 @@
+import type { AccountTenant } from "../../modules/serviceaccount/entities";
+/** What an application whose accounts are confined to tenants (go-core's `serviceaccount.Tenants`) tells the screens. */
+export interface ServiceAccountTenants {
+    /** The i18n key that names a tenant in the application's words (`serviceaccounts.tenant` -> "Dealer"): a column, a field, a row. */
+    readonly labelKey: string;
+    /** The tenants an account can be confined to, among the ones the signed-in person may choose (the server refuses the others). */
+    readonly options: (signal: AbortSignal) => Promise<readonly AccountTenant[]>;
+}
+/** What the screens of `serviceAccountsFeature` need from the feature that installed them. */
+export interface ServiceAccountsContext {
+    /** `null`: the application has no tenants, accounts belong to the organization and no tenant is shown or asked. */
+    readonly tenants: ServiceAccountTenants | null;
+}
+export declare const serviceAccountsContextKey: import("vue").InjectionKey<ServiceAccountsContext>, useServiceAccountsContext: () => ServiceAccountsContext;

package/dist/identity/serviceaccounts/feature.d.ts

@@ -0,0 +1,23 @@
+import { type Feature } from "../../app";
+import type { Destination } from "../../router";
+import { type ServiceAccountTenants } from "./context";
+export interface ServiceAccountsFeatureOptions {
+    /** The tenants accounts are confined to (go-core's `serviceaccount.Tenants`): names the tenant and lists the ones to choose. Without it no tenant is shown or asked for. */
+    tenants?: ServiceAccountTenants;
+    /** The destination of the backend's menu that opens the list. Without it the application binds the list itself. */
+    destination?: Destination;
+}
+/**
+ * The screens of go-core's service accounts, one feature to install: the list (`/iam/service-accounts`, route
+ * `serviceaccounts.index`) and an account's record (`serviceaccounts.record`) with its data, its access (the roles it holds,
+ * the same panel as a person's) and its API keys: a key is made in a sheet that shows its secret once, with *Copy*, and is revoked
+ * from its row. Every screen and action is behind the permission go-core checks for it (`iam.serviceaccount:view`, `manage`,
+ * `revoke`), so an application installs it for everyone and the server's catalogue decides who sees what. The server must have
+ * service accounts on (`identity.WithServiceAccounts`).
+ *
+ * An account has no password and cannot sign in; it calls the API with an `X-API-Key` header. It needs `accessFeature()` next to
+ * it: the roles of an account are the access screens'.
+ *
+ *   createApplication({ platform, shell: backofficeShell(), features: [identityFeature(), accessFeature({ catalogue }), serviceAccountsFeature({ destination: "serviceaccounts" })] })
+ */
+export declare function serviceAccountsFeature(options?: ServiceAccountsFeatureOptions): Feature;

package/dist/identity/serviceaccounts/form.d.ts

@@ -0,0 +1,4 @@
+/** A key's optional expiry: the end of the chosen day (`YYYY-MM-DD`), as the moment the API takes; none for no day. */
+export declare function expiryOf(day: string | null | undefined): string | null;
+/** Today as the date field takes it (`YYYY-MM-DD`), on the clock of the person. */
+export declare function todayOf(now?: Date): string;

package/dist/identity/serviceaccounts/messages.d.ts

@@ -0,0 +1,11 @@
+import type { FormFailureKind } from "../../form";
+/**
+ * What the forms of these screens speak: go-core's refusals as `useServerMessages` words them, and a refused delegation
+ * (`authz.*`: the actor may not give that role, the account's tenant is elsewhere) in the access screens' own words. Spread
+ * into `useCommand` / `useRecordDialog`; `sentence` is the same for a toast. Call it in `setup`.
+ */
+export declare function useAccountMessages(): {
+    failureMessage: (kind: FormFailureKind, error: unknown) => string | undefined;
+    sentence: (error: unknown, fallback?: string) => string;
+    describeFieldError: (message: string) => string;
+};

package/dist/identity/serviceaccounts/routes.d.ts

@@ -0,0 +1,22 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The routes of `serviceAccountsFeature`: typed targets for links (`serviceAccountsRoutes.index`,
+ * `serviceAccountsRoutes.record({ id })`), and the records the feature installs. The names and paths are fixed, so a
+ * link or a menu binding of the application can name them. The record opens on `?tab=general | access | keys`.
+ */
+export interface ServiceAccountsRoutes {
+    /** The records `serviceAccountsFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "serviceaccounts.index";
+    };
+    readonly record: (params: {
+        id: string | number;
+    }) => {
+        readonly name: "serviceaccounts.record";
+        readonly params: {
+            id: string | number;
+        };
+    };
+}
+export declare const serviceAccountsRoutes: ServiceAccountsRoutes;