@cratis/arc 18.0.0

package/identity/IdentityProvider.ts

@@ -0,0 +1,85 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { IIdentityProvider } from './IIdentityProvider';
+import { IIdentity } from './IIdentity';
+import { IdentityProviderResult } from './IdentityProviderResult';
+import { GetHttpHeaders } from 'GetHttpHeaders';
+
+/**
+ * Represents an implementation of {@link IIdentityProvider}.
+*/
+export class IdentityProvider extends IIdentityProvider {
+
+    static readonly CookieName = '.cratis-identity';
+    static httpHeadersCallback: GetHttpHeaders | undefined;
+
+    /**
+     * Sets the HTTP headers callback.
+     * @param callback Callback to set.
+     */
+    static setHttpHeadersCallback(callback: GetHttpHeaders): void {
+        IdentityProvider.httpHeadersCallback = callback;
+    }
+
+    /**
+     * Gets the current identity by optionally specifying the details type.
+     * @returns The current identity as {@link IIdentity}.
+     */
+    static async getCurrent<TDetails = object>(): Promise<IIdentity<TDetails>> {
+        const cookie = this.getCookie();
+        if (cookie.length == 2) {
+            const json = atob(cookie[1]);
+            const result = JSON.parse(json) as IdentityProviderResult;
+            return {
+                id: result.id,
+                name: result.name,
+                details: result.details,
+                isSet: true,
+                refresh: IdentityProvider.refresh
+            } as IIdentity<TDetails>;
+        } else {
+            const identity = await this.refresh<TDetails>();
+            return identity;
+        }
+    }
+
+    /** @inheritdoc */
+    async getCurrent<TDetails = object>(): Promise<IIdentity<TDetails>> {
+        return IdentityProvider.getCurrent<TDetails>();
+    }
+
+    static async refresh<TDetails = object>(): Promise<IIdentity<TDetails>> {
+        IdentityProvider.clearCookie();
+        const response = await fetch(
+            '/.cratis/me', {
+            method: 'GET',
+            headers: IdentityProvider.httpHeadersCallback?.() ?? {}
+        });
+
+        const result = await response.json() as IdentityProviderResult;
+
+        return {
+            id: result.id,
+            name: result.name,
+            details: result.details as TDetails,
+            isSet: true,
+            refresh: IdentityProvider.refresh
+        };
+    }
+
+    private static getCookie() {
+        const decoded = decodeURIComponent(document.cookie);
+        const cookies = decoded.split(';').map(_ => _.trim());
+        const cookie = cookies.find(_ => _.indexOf(`${IdentityProvider.CookieName}=`) == 0);
+        if (cookie) {
+            const keyValue = cookie.split('=');
+            return [keyValue[0].trim(), keyValue[1].trim()];
+        }
+        return [];
+    }
+
+    private static clearCookie() {
+        document.cookie = `${IdentityProvider.CookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+    }
+}

package/identity/IdentityProviderResult.ts

@@ -0,0 +1,8 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export type IdentityProviderResult = {
+    id: string;
+    name: string;
+    details: object;
+};

package/identity/index.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './IdentityProvider';
+export * from './IdentityProviderResult';
+export * from './IIdentityProvider';
+export * from './IIdentity';

package/index.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import * as commands from './commands';
+import * as identity from './identity';
+import * as queries from './queries';
+import * as validation from './validation';
+import * as reflection from './reflection';
+export * from './joinPaths';
+export * from './deepEqual';
+export * from './Globals';
+export * from './ICanBeConfigured';
+export * from './GetHttpHeaders';
+
+export {
+    commands,
+    identity,
+    queries,
+    validation,
+    reflection,
+};

package/joinPaths.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export function joinPaths(...paths) {
+    const joined = paths.join('/');
+    return joined.replace('//', '/');
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@cratis/arc",
+    "version": "18.0.0",
+    "description": "",
+    "author": "Cratis",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/cratis/arc.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist",
+        "**/*.ts",
+        "**/*.tsx"
+    ],
+    "type": "module",
+    "main": "dist/cjs/index.js",
+    "module": "dist/esm/index.js",
+    "types": "dist/esm/index.d.ts",
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./dist/esm/index.d.ts",
+            "require": "./dist/cjs/index.js",
+            "import": "./dist/esm/index.js"
+        },
+        "./commands": {
+            "types": "./dist/esm/commands/index.d.ts",
+            "import": "./dist/esm/commands/index.js",
+            "require": "./dist/cjs/commands/index.js"
+        },
+        "./identity": {
+            "types": "./dist/esm/identity/index.d.ts",
+            "import": "./dist/esm/identity/index.js",
+            "require": "./dist/cjs/identity/index.js"
+        },
+        "./queries": {
+            "types": "./dist/esm/queries/index.d.ts",
+            "import": "./dist/esm/queries/index.js",
+            "require": "./dist/cjs/queries/index.js"
+        },
+        "./validation": {
+            "types": "./dist/esm/validation/index.d.ts",
+            "import": "./dist/esm/validation/index.js",
+            "require": "./dist/cjs/validation/index.js"
+        },
+        "./reflection": {
+            "types": "./dist/esm/reflection/index.d.ts",
+            "import": "./dist/esm/reflection/index.js",
+            "require": "./dist/cjs/reflection/index.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn g:build",
+        "clean": "yarn g:clean",
+        "build": "yarn g:build",
+        "lint": "yarn g:lint",
+        "lint:ci": "yarn g:lint:ci",
+        "test": "yarn g:test",
+        "test:watch": "yarn g:test:watch",
+        "ci": "yarn g:ci",
+        "up": "yarn g:up"
+    },
+    "dependencies": {
+        "@cratis/fundamentals": "^7.2.3"
+    }
+}

package/queries/IObservableQueryConnection.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { DataReceived } from './ObservableQueryConnection';
+
+/**
+ * Defines a connection for observable queries.
+ */
+export interface IObservableQueryConnection<TDataType> {
+    /**
+     * Connect to a specific route.
+     * @param {DataReceived<TDataType> dataReceived Callback that will receive the data.
+     * @param queryArguments Optional query arguments to pass along.
+     */
+    connect(dataReceived: DataReceived<TDataType>, queryArguments?: object): void;
+
+    /**
+     * Disconnect the connection.
+     */
+    disconnect();
+}

package/queries/IObservableQueryFor.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ObservableQuerySubscription } from './ObservableQuerySubscription';
+import { QueryResult } from './QueryResult';
+import { IQuery } from './IQuery';
+import { IHaveParameters } from '../reflection/IHaveParameters';
+
+/**
+ * The delegate type representing the callback of result from the server.
+ */
+export type OnNextResult<TDataType> = (data: TDataType) => void;
+
+/**
+ * Defines the base of a query.
+ * @template TDataType Type of model the query is for.
+ * @template TArguments Optional type of arguments to use for the query.
+ */
+export interface IObservableQueryFor<TDataType, TArguments = object> extends IQuery, IHaveParameters {
+    readonly route: string;
+    readonly requiredRequestParameters: string[];
+    readonly defaultValue: TDataType;
+
+    /**
+     * Subscribe to the query. This will create a subscription onto the server.
+     * @param {OnNextResult} callback The callback that will receive result from the server.
+     * @param [args] Optional arguments for the query - depends on whether or not the query needs arguments.
+     * @returns {ObservableQuerySubscription<TDataType>}.
+     */
+    subscribe(callback: OnNextResult<QueryResult<TDataType>>, args?: TArguments): ObservableQuerySubscription<TDataType>;
+
+    /**
+     * Perform the query using HTTP to get a single result instead of subscribing via WebSocket.
+     * @param [args] Optional arguments for the query - depends on whether or not the query needs arguments.
+     * @returns {Promise<QueryResult<TDataType>>} for the model
+     */
+    perform(args?: TArguments): Promise<QueryResult<TDataType>>;
+}

package/queries/IQuery.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ICanBeConfigured } from '../ICanBeConfigured';
+import { Paging } from './Paging';
+import { Sorting } from './Sorting';
+
+/**
+ * Defines the commonalities between all query types.
+ */
+export interface IQuery extends ICanBeConfigured {
+    /**
+     * Gets the sorting for the query.
+     */
+    get sorting(): Sorting;
+
+    /**
+     * Sets the sorting for the query.
+     */
+    set sorting(value: Sorting);
+
+    /**
+     * Gets the paging for the query.
+     */
+    get paging(): Paging;
+
+    /**
+     * Sets the paging for the query.
+     */
+    set paging(value: Paging);
+}

package/queries/IQueryFor.ts

@@ -0,0 +1,36 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryResult } from './QueryResult';
+import { IQuery } from './IQuery';
+import { IHaveParameters } from '../reflection/IHaveParameters';
+
+/**
+ * Defines the base of a query.
+ * @template TDataType Type of model the query is for.
+ * @template TArguments Optional type of arguments to use for the query.
+ */
+export interface IQueryFor<TDataType, TArguments = object> extends IQuery, IHaveParameters {
+    readonly route: string;
+    readonly requiredRequestParameters: string[];
+    readonly defaultValue: TDataType;
+
+    /**
+     * Gets the current arguments for the query.
+     */
+    get parameters(): TArguments | undefined;
+
+    /**
+     * Sets the current arguments for the query.
+     */
+    set parameters(value: TArguments);
+
+    /**
+     * Perform the query, optionally giving arguments to use. If not given, it will use the arguments that has been set.
+     * By specifying the arguments, it will use these as the current arguments for the instance and subsequent calls does
+     * not need to specify arguments.
+     * @param [args] Optional arguments for the query - depends on whether or not the query needs arguments.
+     * @returns {QueryResult} for the model
+     */
+    perform(args?: TArguments): Promise<QueryResult<TDataType>>;
+}

package/queries/IQueryProvider.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { IQuery } from './IQuery';
+
+/**
+ * Defines the provider for queries.
+ */
+export abstract class IQueryProvider {
+
+    /**
+     * Gets a new instance of a specific query type.
+     * @param {Constructor} queryType Type of query to get an instance of.
+     */
+    abstract get<T extends IQuery>(queryType: Constructor<T>): T;
+}

package/queries/IQueryResult.ts

@@ -0,0 +1,60 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ValidationResult } from '../validation/ValidationResult';
+import { PagingInfo } from './PagingInfo';
+
+/**
+ * Defines the result from executing a query.
+ */
+export interface IQueryResult<TDataType> {
+    /**
+     * Gets the data result from the query.
+     */
+    readonly data: TDataType;
+
+    /**
+     * Gets the paging information.
+     */
+    readonly paging: PagingInfo;
+
+    /**
+     * Gets whether or not the query executed successfully.
+     */
+    readonly isSuccess: boolean;
+
+    /**
+     * Gets whether or not the query was authorized to execute.
+     */
+    readonly isAuthorized: boolean;
+
+    /**
+     * Gets whether or not the query is valid.
+     */
+    readonly isValid: boolean;
+
+    /**
+     * Gets whether or not there are any exceptions that occurred.
+     */
+    readonly hasExceptions: boolean;
+
+    /**
+     * Gets any validation errors. If this collection is empty, there are errors.
+     */
+    readonly validationResults: ValidationResult[];
+
+    /**
+     * Gets any exception messages that might have occurred.
+     */
+    readonly exceptionMessages: string[];
+
+    /**
+     * Gets the stack trace if there was an exception.
+     */
+    readonly exceptionStackTrace: string;
+
+    /**
+     * Gets whether or not the query has data.
+     */
+    readonly hasData: boolean;
+}

package/queries/NullObservableQueryConnection.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { DataReceived } from './ObservableQueryConnection';
+import { IObservableQueryConnection } from './IObservableQueryConnection';
+import { QueryResult } from './QueryResult';
+
+/**
+ * Represents a {@link IObservableQueryConnection} when for instance one can't establish a connection.
+ */
+
+export class NullObservableQueryConnection<TDataType> implements IObservableQueryConnection<TDataType> {
+    /**
+     * Initializes a new instance of the {@link NullObservableQueryConnection} class.
+     * @param {TDataType} defaultValue The default value to serve.
+     */
+    constructor(readonly defaultValue: TDataType) {
+    }
+
+    /** @inheritdoc */
+    connect(dataReceived: DataReceived<TDataType>) {
+        dataReceived(QueryResult.empty(this.defaultValue));
+    }
+
+    /** @inheritdoc */
+    /* eslint-disable @typescript-eslint/no-empty-function */
+    disconnect() {
+    }
+}

package/queries/ObservableQueryConnection.ts

@@ -0,0 +1,118 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Globals } from '../Globals';
+import { IObservableQueryConnection } from './IObservableQueryConnection';
+import { QueryResult } from './QueryResult';
+
+export type DataReceived<TDataType> = (data: QueryResult<TDataType>) => void;
+
+/**
+ * Represents the connection for an observable query.
+ */
+export class ObservableQueryConnection<TDataType> implements IObservableQueryConnection<TDataType> {
+
+    private _socket!: WebSocket;
+    private _disconnected = false;
+    private _url: string;
+
+    /**
+     * Initializes a new instance of the {@link ObservableQueryConnection<TDataType>} class.
+     * @param {Url} url The fully qualified Url.
+     */
+    constructor(url: URL, private readonly _microservice: string) {
+        const secure = url.protocol?.indexOf('https') === 0 || false;
+
+        this._url = `${secure ? 'wss' : 'ws'}://${url.host}${url.pathname}${url.search}`;
+        if (this._microservice?.length > 0) {
+            const microserviceParam = `${Globals.microserviceWSQueryArgument}=${this._microservice}`;
+            if (this._url.indexOf('?') > 0) {
+                this._url = `${this._url}&${microserviceParam}`;
+            } else {
+                this._url = `${this._url}?${microserviceParam}`;
+            }
+        }
+    }
+
+    /**
+     * Disposes the connection.
+     */
+    dispose() {
+        this.disconnect();
+    }
+
+    /** @inheritdoc */
+    connect(dataReceived: DataReceived<TDataType>, queryArguments?: object) {
+        let url = this._url;
+        if (queryArguments) {
+            if (url.indexOf('?') < 0) {
+                url = `${url}?`;
+            } else {
+                url = `${url}&`;
+            }
+            const query = Object.keys(queryArguments).map(key => `${key}=${queryArguments[key]}`).join('&');
+            url = `${url}${query}`;
+        }
+
+        let timeToWait = 500;
+        const timeExponent = 500;
+        const retries = 100;
+        let currentAttempt = 0;
+        const maxTime = 10_000;
+
+        const connectSocket = () => {
+            const retry = () => {
+                currentAttempt++;
+                if (currentAttempt > retries) {
+                    console.log(`Attempted ${retries} retries for route '${url}'. Abandoning.`);
+                    return;
+                }
+                console.log(`Attempting to reconnect for '${url}' (#${currentAttempt})`);
+
+                setTimeout(connectSocket, timeToWait);
+                timeToWait += (timeExponent * currentAttempt);
+                timeToWait = timeToWait > maxTime ? maxTime : timeToWait; 
+            };
+
+            this._socket = new WebSocket(url);
+            this._socket.onopen = () => {
+                if (this._disconnected) return;
+                console.log(`Connection for '${url}' established`);
+                timeToWait = 500;
+                currentAttempt = 0;
+            };
+            this._socket.onclose = () => {
+                if (this._disconnected) return;
+                console.log(`Unexpected connection closed for route '${url}'`);
+                retry();
+            };
+            this._socket.onerror = (error) => {
+                if (this._disconnected) return;
+                console.log(`Error with connection for '${url}' - ${error}`);
+                retry();
+            };
+            this._socket.onmessage = (ev) => {
+                if (this._disconnected) {
+                    console.log('Received message after closing connection');
+                    return;
+                }
+                dataReceived(JSON.parse(ev.data));
+            };
+        };
+
+        if (this._disconnected) return;
+        connectSocket();
+    }
+
+    /** @inheritdoc */
+    disconnect() {
+        if (this._disconnected) {
+            return;
+        }
+        console.log(`Disconnecting '${this._url}'`);
+        this._disconnected = true;
+        this._socket?.close();
+        console.log(`Connection for '${this._url}' closed`);
+        this._socket = undefined!;
+    }
+}