@cortezaproject/corteza-vue 2024.9.4 → 2024.9.5-dev.2

package/dist/src/plugins/auth.d.ts

@@ -0,0 +1,217 @@
+import { AxiosInstance } from 'axios';
+import { system } from '@cortezaproject/corteza-js';
+import { PluginFunction } from 'vue';
+declare const accessToken: unique symbol;
+declare const user: unique symbol;
+type eventListenerSignature = <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions) => void;
+interface AuthInfo {
+    accessTokenFn: () => string | undefined;
+    user: system.User;
+}
+interface PluginOpts {
+    cortezaAuthURL: string;
+    callbackURL: string;
+}
+interface AuthCtor {
+    app: string;
+    /**
+     * when true, use console as a logger, no-op otherwise.
+     */
+    verbose: boolean;
+    /**
+     * where the authe backend is
+     */
+    cortezaAuthURL: string;
+    /**
+     * URL we'll be listening to for callbacksa
+     */
+    callbackURL: string;
+    /**
+     * used for redirection
+     */
+    location: Location;
+    /**
+     * used for storing
+     */
+    sessionStorage: Storage;
+    /**
+     * used for event listeners
+     */
+    registerEventListener: eventListenerSignature;
+    /**
+     * Static string with entry-point URL stored at app init
+     * so that there is no risk of changes when Vue router gets it's hands on it
+     */
+    entrypointURL: string;
+    /**
+     * multiply factor for token expiration
+     * this will tell internal refresh system how much
+     * before the token expiration we'll refresh the access toke
+     *
+     * keep in mind that access token is exchanged on every app load
+     */
+    refreshFactor: number;
+}
+interface Logger {
+    debug(...data: unknown[]): void;
+    info(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+}
+export declare class Auth {
+    /**
+     * Access token is only stored here (in-memory)!
+     * we do not want to keep it in the local store
+     */
+    private [accessToken]?;
+    /**
+     * Access token is only stored here (in-memory)!
+     * we do not want to keep it in the local store
+     */
+    private [user]?;
+    /**
+     * Name of the app that is using the auth plugin
+     */
+    readonly app: string;
+    readonly refreshFactor: number;
+    readonly verbose: boolean;
+    readonly cortezaAuthURL: string;
+    readonly callbackURL: string;
+    readonly location: Location;
+    readonly sessionStorage: Storage;
+    readonly registerEventListener: eventListenerSignature;
+    /**
+     * Application entrypoint URL
+     */
+    readonly entrypointURL: string;
+    /**
+     * Keeps track of timeout callback in case we re-run it before it timesout
+     * @private
+     */
+    private refreshTimeout?;
+    private expiresIn;
+    private $emit?;
+    constructor({ app, verbose, cortezaAuthURL, callbackURL, entrypointURL, location, sessionStorage, refreshFactor, registerEventListener }: AuthCtor);
+    vue(vue: Vue): Auth;
+    get axios(): AxiosInstance;
+    /**
+     * wrapper for console (when in debug mode) or a simple no-op obj
+     */
+    get log(): Logger;
+    /**
+     * Returns function that returns current access token
+     */
+    get accessTokenFn(): () => string | undefined;
+    /**
+     * Handles initial authentication check
+     *
+     * handle function should be called immediately when application is created
+     * it checks whether app was requested on an URL with /auth/callback at the end
+     * if there is an error or code passed and handles that request appropriately:
+     *
+     *  .../auth/callback?code=... exchanged authorization code for access token
+     *  .../auth/callback?error=... renders an error that we got from the oauth2 provider
+     *
+     * If handle was called without /auth/callback or without params mentioned above:
+     *   if user is not authorized, redirect to the configured path to start oauth2 flow
+     *   if user is authorized, continue with execution
+     */
+    handle(req?: URL): Promise<AuthInfo | null>;
+    /**
+     * Flagging session storage
+     *
+     * Challenge with sessions and browser tabs:
+     * Each browser tab & window interacts with an isolated session. When user clicks on a link to and wants to open
+     * it in a new window or a tab, or when tab is duplicated, session contents are copied!
+     *
+     * Consequences of that are that two (or more) tabs end up with the same session
+     * and the same refresh token, and we need to detect if we're dealing with refresh token in an old or new  session.
+     *
+     * With this function we start the final state and flag the session. This way we'll
+     * know, after the redirection to the final location, if this is a final stage or not and if the refresh token
+     * belongs to this session or not.
+     */
+    handleStateManagement(): boolean;
+    bindListeners(): void;
+    cleanFlags(): void;
+    /**
+     * Called when refresh token is re-fetched.
+     *
+     * Cleanup aux items in the session store
+     */
+    completeFinalState(): void;
+    /**
+     * Exchanges the auth parameters for access & refresh token.
+     *
+     * If the parameters are correct and exchange is successful, the refresh token
+     * gets stored in localStorage for further use, the access token and current user get stored
+     * in-memory.
+     *
+     * Function will throw null when user is unauthenticated
+     */
+    handleCallbackRoute(state: string | null, code: string): Promise<AuthInfo | null>;
+    /**
+     * Checks current auth state; is access token loaded OR do we have a refresh token we can use
+     *
+     * check uses system API client verify given/current JWT
+     *
+     * If JWT is valid, it is stored into local storage alongside
+     * loaded user.
+     *
+     * We're explicitly passing systemAPI to minimize plugin initialization complexity
+     *
+     * Function will throw null when user is unauthenticated
+     */
+    handleState(): Promise<AuthInfo | null>;
+    logout(): void;
+    /**
+     * Starts new authentication flow
+     *
+     * It generates simple rand state to harden security and to
+     * keep track of before-flow-start location of the user
+     */
+    startAuthenticationFlow(): void;
+    getRedirect(url: string): string;
+    isCallback(url: string): boolean;
+    /**
+     * protects against too many tries when we try to auto-fix the "state does not match" error
+     * by restarting the aut flow.
+     */
+    private incFlowCounter;
+    startAutoLogout(): Promise<number>;
+    stopAutoLogout(): Promise<AuthInfo | null>;
+    /**
+     * Exchanges authorization code for access and refresh tokens
+     */
+    private exchangeCode;
+    /**
+     * Exchanges refresh token for new access and new refresh token
+     *
+     * After successful token exchange, we call response processing function
+     * to update internals & stored values
+     *
+     * @param refreshToken
+     */
+    private exchangeRefresh;
+    /**
+     * Processes fetched token and stores it
+     *
+     * Access token is stored only to instance of this object
+     * Refresh token is stored only to local store
+     *
+     * @param oa2tkn OAuth2 token response
+     * @private
+     */
+    private procTokenResponse;
+    /**
+     * oauth2token exchanges authorization code or refresh token for (new) access token
+     *
+     * @param payload
+     * @private
+     */
+    private oauth2token;
+    private pruneStore;
+    get accessToken(): string | undefined;
+    get user(): system.User | undefined;
+}
+export default function (): PluginFunction<PluginOpts>;
+export {};

package/dist/src/plugins/corteza-api.d.ts

@@ -0,0 +1,15 @@
+import { PluginFunction } from 'vue';
+interface Options {
+    baseURL?: string;
+    accessTokenFn?: () => string | undefined;
+}
+/**
+ * Generic Corteza API plugin
+ *
+ * Install a specific plugin:
+ * Vue.use(plugins.CortezaAPI('compose'))
+ *
+ * @constructor
+ */
+export default function (service: string, opt?: Options): PluginFunction<Options>;
+export {};

package/dist/src/plugins/eventbus.d.ts

@@ -0,0 +1,3 @@
+import { PluginFunction } from 'vue';
+import { eventbus } from '@cortezaproject/corteza-js';
+export default function (): PluginFunction<Partial<eventbus.Options>>;

package/dist/src/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { default as CortezaAPI } from './corteza-api';
+export { default as Auth } from './auth';
+export { default as UIHooks } from './ui-hooks';
+export { default as EventBus } from './eventbus';
+export { default as Settings } from './settings';
+export { default as Reminder } from './reminder';
+export { default as I18n } from '../i18n';

package/dist/src/plugins/ui-hooks.d.ts

@@ -0,0 +1,74 @@
+import { PluginFunction } from 'vue';
+import { eventbus } from '@cortezaproject/corteza-js';
+interface UIProp {
+    name: string;
+    value: string;
+}
+interface Trigger {
+    resourceTypes: string[];
+    eventTypes: string[];
+    uiProps: UIProp[];
+    constraints: object[];
+    weight?: number;
+}
+interface Script {
+    name: string;
+    label: string;
+    description?: string;
+    errors?: string[];
+    triggers: Trigger[];
+}
+export declare class Button {
+    readonly label: string;
+    readonly description?: string;
+    readonly script: string;
+    readonly resourceType: string;
+    readonly weight: number;
+    readonly variant?: string;
+    readonly page?: string;
+    readonly slot?: string;
+    readonly constraints: eventbus.ConstraintMatcher[];
+    constructor(s: Script, t: Trigger);
+}
+/**
+ * Consumes scripts that can be triggered manually and converts it to list of buttons
+ *
+ * These buttons can put manually to various compose page block or
+ * positioned automatically on designated pages & slots
+ */
+export declare class UIHooks {
+    readonly app: string;
+    readonly verbose = false;
+    protected set: Button[];
+    constructor(opt: string | Partial<UIHooks>);
+    /**
+     * Takes one or more scripts and converts them to buttons
+     *
+     * With every script added it removes ALL
+     * buttons that use the same script
+     */
+    Register(...scripts: Script[]): void;
+    /**
+     * Remove all buttons that match a script
+     * @param name
+     * @constructor
+     */
+    Unregister({ name }: Script): void;
+    /**
+     * Searches for buttons that match the requirements
+     *
+     * This is used in 2 kinds of places:
+     *  - currated list of buttons in compose blocks where admin can
+     *    picks, reorder, name and style scripts by hand
+     *  - different slots on pages where scripts are automatically placed
+     *
+     * @param resourceType
+     * @param page
+     * @param slot
+     * @constructor
+     */
+    Find(resourceType: string | string[], page?: string, slot?: string): Button[];
+    FindByScript(script: string): Button | undefined;
+}
+export default function (): PluginFunction<Partial<UIHooks>>;
+export {};

package/dist/src/store/RBAC.d.ts

@@ -0,0 +1,15 @@
+import { StoreOptions } from 'vuex';
+interface Rule {
+    resource: string;
+    operation: string;
+    allow: boolean;
+}
+interface State {
+    loaded: boolean;
+    rules: Array<Rule>;
+}
+interface Fetcher {
+    permissionsEffective: () => Promise<Array<Rule>>;
+}
+export default function (...apis: Array<Fetcher>): StoreOptions<State>;
+export {};

package/dist/src/store/index.d.ts

@@ -0,0 +1,3 @@
+export { default as wfPrompts } from './wf-prompts';
+export { default as RBAC } from './RBAC';
+export { default as notifications } from './notifications';

package/dist/src/store/notifications/index.d.ts

@@ -0,0 +1,16 @@
+import { apiClients, system } from '@cortezaproject/corteza-js';
+import { StoreOptions } from 'vuex';
+interface Options {
+    api: apiClients.System;
+    ws: WebSocket;
+    watchInterval: number;
+    webapp: string;
+}
+interface State {
+    notifications: Array<system.Notification>;
+    visible: boolean;
+    pageCursor: string | null;
+    muted: boolean;
+}
+export default function ({ api }: Options): StoreOptions<State>;
+export {};

package/dist/src/store/wf-prompts/index.d.ts

@@ -0,0 +1,21 @@
+import { apiClients, automation } from '@cortezaproject/corteza-js';
+import { StoreOptions } from 'vuex';
+interface Options {
+    api: apiClients.Automation;
+    ws: WebSocket;
+    watchInterval: number;
+    webapp: string;
+}
+interface State {
+    loading: boolean;
+    prompts: Array<automation.Prompt>;
+    /**
+     * Is prompt component active (modal open)?
+     *   prompt = modal is open, show this/current prompt
+     *   true   = modal is open, show list of pending prompts
+     *   false  = modal is closed
+     */
+    active: automation.Prompt | boolean;
+}
+export default function ({ api, webapp }: Options): StoreOptions<State>;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cortezaproject/corteza-vue",
   "description": "Corteza Vue.js JavaScript/TypeScript libs",
-  "version": "2024.9.4",
+  "version": "2024.9.5-dev.2",
   "license": "Apache-2.0",
   "author": "Denis Arh <denis.arh@crust.tech>",
   "type": "module",
@@ -30,15 +30,29 @@
   "resolutions": {
     "postcss": "^8.5.3",
     "json5": "^2.2.3",
-    "loader-utils": "^3.2.0"
+    "loader-utils": "^3.2.0",
+    "prosemirror-model": "^1.25.0"
   },
   "dependencies": {
-    "@cortezaproject/corteza-js": "^2024.9.4",
+    "@cortezaproject/corteza-js": "^2024.9.5-dev.2",
+    "@floating-ui/dom": "^1.7.4",
     "@fortawesome/fontawesome-svg-core": "^6.7.2",
     "@fortawesome/free-solid-svg-icons": "^6.7.2",
     "@fortawesome/vue-fontawesome": "^2.0.10",
     "@panter/vue-i18next": "^0.15.0",
     "@popperjs/core": "^2.11.8",
+    "@tiptap/core": "^3.4.2",
+    "@tiptap/extension-list": "^3.4.2",
+    "@tiptap/extension-mention": "^3.4.2",
+    "@tiptap/extension-placeholder": "^3.4.2",
+    "@tiptap/extension-table": "^3.4.2",
+    "@tiptap/extension-text-align": "^3.4.2",
+    "@tiptap/extension-text-style": "^3.4.2",
+    "@tiptap/extensions": "^3.4.2",
+    "@tiptap/pm": "^3.4.2",
+    "@tiptap/starter-kit": "^3.4.2",
+    "@tiptap/suggestion": "^3.4.2",
+    "@tiptap/vue-2": "^3.4.2",
     "bootstrap-vue": "2.23.1",
     "echarts": "5.6.0",
     "fuzzysort": "^3.1.0",
@@ -57,14 +71,11 @@
     "pino": "^9.6.0",
     "portal-vue": "^3.0.0",
     "qs": "^6.14.0",
-    "tiptap": "^1.32.2",
-    "tiptap-extensions": "^1.35.2",
     "v-photoswipe": "^1.0.3-1",
     "vue": "2.7.16",
     "vue-color": "^2.8.1",
     "vue-echarts": "7.0.3",
     "vue-select": "3.20.3",
-    "vue-swatches": "^2.1.1",
     "vue2-ace-editor": "^0.0.15",
     "vue2-leaflet": "^2.7.1",
     "vuedraggable": "^2.24.3",