remult 0.22.2 → 0.22.3

package/esm/core/src/buildRestDataProvider.js

@@ -1,113 +0,0 @@
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
-export function buildRestDataProvider(provider) {
-    if (!provider)
-        return new RestDataProviderHttpProviderUsingFetch();
-    let httpDataProvider;
-    if (!httpDataProvider) {
-        if (isExternalHttpProvider(provider)) {
-            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
-        }
-    }
-    if (!httpDataProvider) {
-        if (typeof provider === "function") {
-            httpDataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
-        }
-    }
-    return httpDataProvider;
-}
-export function isExternalHttpProvider(item) {
-    let http = item;
-    if (http && http.get && http.put && http.post && http.delete)
-        return true;
-    return false;
-}
-export class HttpProviderBridgeToRestDataProviderHttpProvider {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    async post(url, data) {
-        return await retry(() => toPromise(this.http.post(url, data)));
-    }
-    delete(url) {
-        return toPromise(this.http.delete(url));
-    }
-    put(url, data) {
-        return toPromise(this.http.put(url, data));
-    }
-    async get(url) {
-        return await retry(() => toPromise(this.http.get(url)));
-    }
-}
-export async function retry(what) {
-    let i = 0;
-    while (true) {
-        try {
-            return await what();
-        }
-        catch (err) {
-            if ((err.message?.startsWith("Error occurred while trying to proxy") ||
-                err.message?.startsWith("Error occured while trying to proxy") ||
-                err.message?.includes("http proxy error") ||
-                err.message?.startsWith("Gateway Timeout") ||
-                err.status == 500) && i++ < 50) {
-                await new Promise((res, req) => {
-                    setTimeout(() => {
-                        res({});
-                    }, 250);
-                });
-                continue;
-            }
-            throw err;
-        }
-    }
-}
-export function toPromise(p) {
-    let r;
-    if (p["toPromise"] !== undefined) {
-        r = p["toPromise"]();
-    }
-    //@ts-ignore
-    else
-        r = p;
-    return r.then((x) => {
-        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
-            return x.data;
-        return x;
-    }).catch(async (ex) => {
-        throw await processHttpException(ex);
-    });
-}
-export async function processHttpException(ex) {
-    let z = await ex;
-    var error;
-    if (z.error)
-        error = z.error;
-    else if (z.isAxiosError) {
-        if (typeof z.response?.data === "string")
-            error = z.response.data;
-        else
-            error = z?.response?.data;
-    }
-    if (!error)
-        error = z.message;
-    if (z.status == 0 && z.error.isTrusted)
-        error = "Network Error";
-    if (typeof error === 'string') {
-        error = {
-            message: error,
-        };
-    }
-    if (z.modelState)
-        error.modelState = z.modelState;
-    let httpStatusCode = z.status;
-    if (httpStatusCode === undefined)
-        httpStatusCode = z.response?.status;
-    if (httpStatusCode !== undefined && httpStatusCode !== null) {
-        error.httpStatusCode = httpStatusCode;
-    }
-    var result = Object.assign(error, {
-    //     exception: ex disabled for now because JSON.stringify crashed with this
-    });
-    return result;
-}

package/esm/core/src/column-interfaces.d.ts

@@ -1,154 +0,0 @@
-import { ClassType } from '../classType';
-import { Allowed, AllowedForInstance } from './context';
-import { EntityMetadata, FieldRef, OmitEB } from './remult3';
-export interface FieldOptions<entityType = any, valueType = any> {
-    /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
-    * @example
-    * <input placeholder={taskRepo.metadata.fields.title.caption}/>
-    */
-    caption?: string;
-    /** If it can store null in the database */
-    allowNull?: boolean;
-    /** If this field data is included in the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    includeInApi?: Allowed;
-    /** If this field data can be updated in the api.
-    * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    allowApiUpdate?: AllowedForInstance<entityType>;
-    /** An arrow function that'll be used to perform validations on it
-     * @example
-     * @Fields.string({
-     *   validate: Validators.required
-     * })
-     * @example
-     * @Fields.string<Task>({
-     *    validate: task=>{
-     *      if (task.title.length<3)
-     *          throw "Too Short";
-     *   }
-     * })
-     * @example
-     * @Fields.string({
-     *    validate: (_, fieldRef)=>{
-     *      if (fieldRef.value.length<3)
-     *          fieldRef.error = "Too Short";
-     *   }
-     * })
-     */
-    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
-    /** Will be fired before this field is saved to the server/database */
-    saving?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>));
-    /**  An expression that will determine this fields value on the backend and be provided to the front end*/
-    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
-    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
-    dbName?: string;
-    /** Used or fields that are based on an sql expressions, instead of a physical table column
-     * @example
-     *
-     * @Fields.integer({
-     *   sqlExpression:e=> 'length(title)'
-     * })
-     * titleLength = 0;
-     * @Fields.string()
-     * title='';
-    */
-    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
-    /** For fields that shouldn't be part of an update or insert statement */
-    dbReadOnly?: boolean;
-    /** The value converter to be used when loading and saving this field */
-    valueConverter?: ValueConverter<valueType>;
-    /** an arrow function that translates the value to a display value */
-    displayValue?: (entity: entityType, value: valueType) => string;
-    /** an arrow function that determines the default value of the field, when the entity is created using the `repo.create` method */
-    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
-    /** The html input type for this field */
-    inputType?: string;
-    /** Determines if the referenced entity will be loaded immediately or on demand.
-     * @see[Lazy loading of related entities](http://remult.dev/docs/lazy-loading-of-related-entities.html)
-     */
-    lazy?: boolean;
-    /** The value type for this field */
-    valueType?: any;
-    /** The entity type to which this field belongs */
-    target?: ClassType<entityType>;
-    /** The key to be used for this field */
-    key?: string;
-}
-/**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
-export interface FieldMetadata<valueType = any, entityType = any> {
-    /** The field's member name in an object.
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * console.log(taskRepo.metadata.fields.title.key);
-     * // result: title
-     */
-    readonly key: string;
-    /** A human readable caption for the field. Can be used to achieve a consistent caption for a field throughout the app
-     * @example
-     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
-     */
-    readonly caption: string;
-    /** The field's value type (number,string etc...) */
-    readonly valueType: any;
-    /** The options sent to this field's decorator */
-    readonly options: FieldOptions;
-    /** The `inputType` relevant for this field, determined by the options sent to it's decorator and the valueConverter in these options */
-    readonly inputType: string;
-    /** if null is allowed for this field */
-    readonly allowNull: boolean;
-    /** The class that contains this field
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * Task == taskRepo.metadata.fields.title.target //will return true
-    */
-    readonly target: ClassType<valueType>;
-    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
-    getDbName(): Promise<string>;
-    /** Indicates if this field is based on a server express */
-    readonly isServerExpression: boolean;
-    /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
-    readonly dbReadOnly: boolean;
-    /** the Value converter for this field */
-    readonly valueConverter: Required<ValueConverter<valueType>>;
-    /** Get the display value for a specific item
-     * @example
-     * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
-    */
-    displayValue(item: Partial<OmitEB<entityType>>): string;
-    apiUpdateAllowed(item?: Partial<OmitEB<entityType>>): boolean;
-    readonly includedInApi: boolean;
-    /** Adapts the value for usage with html input
-     * @example
-     * @Fields.dateOnly()
-     * birthDate = new Date(1976,5,16)
-     * //...
-     * input.value = repo.fields.birthDate.toInput(person) // will return '1976-06-16'
-     */
-    toInput(value: valueType, inputType?: string): string;
-    /** Adapts the value for usage with html input
-     * @example
-     * @Fields.dateOnly()
-     * birthDate = new Date(1976,5,16)
-     * //...
-     * person.birthDate = repo.fields.birthDate.fromInput(personFormState) // will return Date
-     */
-    fromInput(inputValue: string, inputType?: string): valueType;
-}
-export interface ValueConverter<valueType> {
-    fromJson?(val: any): valueType;
-    toJson?(val: valueType): any;
-    fromDb?(val: any): valueType;
-    toDb?(val: valueType): any;
-    toInput?(val: valueType, inputType?: string): string;
-    fromInput?(val: string, inputType?: string): valueType;
-    displayValue?(val: valueType): string;
-    readonly fieldTypeInDb?: string;
-    readonly inputType?: string;
-}
-export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => void | Promise<void>;
-export declare type ValueOrExpression<valueType> = valueType | (() => valueType);
-export declare function valueOrExpressionToValue<valueType>(f: ValueOrExpression<valueType>): valueType;
-export interface ValueListItem {
-    id?: any;
-    caption?: any;
-}

package/esm/core/src/column-interfaces.js

@@ -1,7 +0,0 @@
-export function valueOrExpressionToValue(f) {
-    if (typeof f === 'function') {
-        let x = f;
-        return x();
-    }
-    return f;
-}

package/esm/core/src/column.d.ts

@@ -1,58 +0,0 @@
-import { ClassType } from '../classType';
-import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
-import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
-export declare function makeTitle(name: string): string;
-export declare class CompoundIdField implements FieldMetadata<string> {
-    fields: FieldMetadata[];
-    constructor(...columns: FieldMetadata[]);
-    apiUpdateAllowed(item: any): boolean;
-    displayValue(item: any): string;
-    includedInApi: boolean;
-    toInput(value: string, inputType?: string): string;
-    fromInput(inputValue: string, inputType?: string): string;
-    getDbName(): Promise<string>;
-    getId(instance: any): string;
-    options: FieldOptions<any, any>;
-    get valueConverter(): Required<ValueConverter<string>>;
-    target: ClassType<any>;
-    readonly: true;
-    allowNull: boolean;
-    dbReadOnly: boolean;
-    isServerExpression: boolean;
-    key: string;
-    caption: string;
-    inputType: string;
-    dbName: string;
-    valueType: any;
-    isEqualTo(value: FieldMetadata<string> | string): EntityFilter<any>;
-    resultIdFilter(id: string, data: any): Filter;
-}
-export declare class LookupColumn<T> {
-    private repository;
-    id: idType<T>;
-    toJson(): any;
-    setId(val: any): void;
-    waitLoadOf(id: any): Promise<T> | null;
-    get(id: any): any;
-    storedItem: {
-        item: T;
-    };
-    set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
-    get item(): T;
-    waitLoad(): Promise<T | null>;
-}
-export declare class OneToMany<T> {
-    private provider;
-    private settings?;
-    constructor(provider: Repository<T>, settings?: ({
-        create?: ((newItem: T) => void) | undefined;
-    } & FindOptions<T>) | undefined);
-    private _items;
-    private _currentPromise;
-    get lazyItems(): T[];
-    load(): Promise<T[]>;
-    private find;
-    create(item?: Partial<T>): T;
-}

package/esm/core/src/column.js

@@ -1,174 +0,0 @@
-import { assign } from '../assign';
-import { Filter } from './filter/filter-interfaces';
-import { getEntityRef, __updateEntityBasedOnWhere } from './remult3';
-export function makeTitle(name) {
-    // insert a space before all caps
-    return name.replace(/([A-Z])/g, ' $1')
-        // uppercase the first character
-        .replace(/^./, (str) => str.toUpperCase()).replace('Email', 'eMail').replace(" I D", " ID");
-}
-export class CompoundIdField {
-    fields;
-    constructor(...columns) {
-        this.fields = columns;
-    }
-    apiUpdateAllowed(item) {
-        throw new Error('Method not implemented.');
-    }
-    displayValue(item) {
-        throw new Error('Method not implemented.');
-    }
-    includedInApi;
-    toInput(value, inputType) {
-        throw new Error('Method not implemented.');
-    }
-    fromInput(inputValue, inputType) {
-        throw new Error('Method not implemented.');
-    }
-    getDbName() {
-        return Promise.resolve("");
-    }
-    getId(instance) {
-        let r = "";
-        this.fields.forEach(c => {
-            if (r.length > 0)
-                r += ',';
-            r += instance[c.key];
-        });
-        return r;
-    }
-    options;
-    get valueConverter() {
-        throw new Error("cant get value converter of compound id");
-    }
-    target;
-    readonly;
-    allowNull;
-    dbReadOnly;
-    isServerExpression;
-    key;
-    caption;
-    inputType;
-    dbName;
-    valueType;
-    isEqualTo(value) {
-        let result = {};
-        let val = value.toString();
-        let id = val.split(',');
-        this.fields.forEach((c, i) => {
-            result[c.key] = id[i];
-        });
-        return result;
-    }
-    resultIdFilter(id, data) {
-        return new Filter(add => {
-            let idParts = [];
-            if (id != undefined)
-                idParts = id.split(',');
-            this.fields.forEach((c, i) => {
-                let val = undefined;
-                if (i < idParts.length)
-                    val = idParts[i];
-                if (data[c.key] != undefined)
-                    val = data[c.key];
-                add.isEqualTo(c, val);
-            });
-        });
-    }
-}
-export class LookupColumn {
-    repository;
-    id;
-    toJson() {
-        if (this.item === null)
-            return null;
-        return this.repository.toJson(this.item);
-    }
-    setId(val) {
-        if (this.repository.metadata.idMetadata.field.valueType == Number)
-            val = +val;
-        this.id = val;
-    }
-    waitLoadOf(id) {
-        if (id === undefined || id === null)
-            return null;
-        return this.repository.getCachedByIdAsync(id);
-    }
-    get(id) {
-        if (id === undefined || id === null)
-            return null;
-        return this.repository.getCachedById(id);
-    }
-    storedItem;
-    set(item) {
-        this.storedItem = undefined;
-        if (item) {
-            if (typeof item === "string" || typeof item === "number")
-                this.id = item;
-            else {
-                let eo = getEntityRef(item, false);
-                if (eo) {
-                    this.repository.addToCache(item);
-                    this.id = eo.getId();
-                }
-                else {
-                    this.storedItem = { item };
-                    this.id = item[this.repository.metadata.idMetadata.field.key];
-                }
-            }
-        }
-        else if (item === null) {
-            this.id = null;
-        }
-        else {
-            this.id = undefined;
-        }
-    }
-    constructor(repository, id) {
-        this.repository = repository;
-        this.id = id;
-    }
-    get item() {
-        if (this.storedItem)
-            return this.storedItem.item;
-        return this.get(this.id);
-    }
-    async waitLoad() {
-        return this.waitLoadOf(this.id);
-    }
-}
-9000;
-export class OneToMany {
-    provider;
-    settings;
-    constructor(provider, settings) {
-        this.provider = provider;
-        this.settings = settings;
-    }
-    _items;
-    _currentPromise;
-    get lazyItems() {
-        this.load();
-        return this._items;
-    }
-    async load() {
-        if (this._currentPromise != null)
-            return this._currentPromise;
-        if (this._items === undefined)
-            this._items = [];
-        return this._currentPromise = this.find().then(x => {
-            this._items.splice(0);
-            this._items.push(...x);
-            return this._items;
-        });
-    }
-    async find() {
-        return this.provider.find(this.settings);
-    }
-    create(item) {
-        let r = this.provider.create();
-        __updateEntityBasedOnWhere(this.provider.metadata, this.settings.where, r);
-        assign(r, item);
-        return r;
-    }
-}

package/esm/core/src/context.d.ts

@@ -1,134 +0,0 @@
-import { DataProvider } from "./data-interfaces";
-import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
-import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQueryClient";
-import type { LiveQueryStorage, LiveQueryChangesListener, SubscriptionServer } from "./live-query/SubscriptionServer";
-import { ExternalHttpProvider } from "./buildRestDataProvider";
-import { SubscriptionClient, Unsubscribe } from "./live-query/SubscriptionChannel";
-export declare class RemultAsyncLocalStorage {
-    private readonly remultObjectStorage;
-    static enable(): void;
-    static disable(): void;
-    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: VoidFunction): void;
-    getRemult(): Remult | undefined;
-    static instance: RemultAsyncLocalStorage;
-}
-export declare function isBackend(): boolean;
-export declare class Remult {
-    /**Return's a `Repository` of the specific entity type
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     * @param entity - the entity to use
-     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
-     */
-    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
-    /** Returns the current user's info */
-    user?: UserInfo;
-    /** Checks if a user was authenticated */
-    authenticated(): boolean;
-    /** checks if the user has any of the roles specified in the parameters
-     * @example
-     * remult.isAllowed("admin")
-     * @see
-     * [Allowed](https://remult.dev/docs/allowed.html)
-     */
-    isAllowed(roles?: Allowed): boolean;
-    /** checks if the user matches the allowedForInstance callback
-     * @see
-     * [Allowed](https://remult.dev/docs/allowed.html)
-     */
-    isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
-    /** The current data provider */
-    dataProvider: DataProvider;
-    repCache: Map<DataProvider, Map<ClassType<any>, Repository<any>>>;
-    /** Creates a new instance of the `remult` object.
-     *
-     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
-     *
-     * If no provider is specified, `fetch` will be used as an http provider
-     */
-    constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
-    constructor(p: DataProvider);
-    constructor();
-    liveQueryStorage?: LiveQueryStorage;
-    subscriptionServer?: SubscriptionServer;
-    liveQueryPublisher: LiveQueryChangesListener;
-    /** Used to call a `backendMethod` using a specific `remult` object
-     * @example
-     * await remult.call(TasksController.setAll, undefined, true);
-     * @param backendMethod - the backend method to call
-     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
-     * @param args - the arguments to send to the backend method
-    */
-    call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
-    liveQuerySubscriber: LiveQueryClient;
-    /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
-    static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
-    clearAllCache(): any;
-    /** A helper callback that is called whenever an entity is created. */
-    static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
-    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
-    readonly context: RemultContext;
-    /** The api client that will be used by `remult` to perform calls to the `api` */
-    apiClient: ApiClient;
-    static run<T>(callback: () => T, options: {
-        dataProvider: DataProvider;
-    }): T;
-}
-export type GetArguments<T> = T extends (...args: infer FirstArgument) => any ? FirstArgument : never;
-export interface RemultContext {
-}
-export interface ApiClient {
-    /** The http client to use when making api calls.
-     * @example
-     * remult.apiClient.httpClient = axios;
-     * @example
-     * remult.apiClient.httpClient = httpClient;//angular http client
-     * @example
-     * remult.apiClient.httpClient = fetch; //this is the default
-     */
-    httpClient?: ExternalHttpProvider | typeof fetch;
-    /** The base url to for making api calls */
-    url?: string;
-    subscriptionClient?: SubscriptionClient;
-    wrapMessageHandling?: (x: VoidFunction) => void;
-}
-export declare const allEntities: ClassType<any>[];
-export interface ControllerOptions {
-    key: string;
-}
-export declare const classHelpers: Map<any, ClassHelper>;
-export declare class ClassHelper {
-    classes: Map<any, ControllerOptions>;
-}
-export declare function setControllerSettings(target: any, options: ControllerOptions): void;
-export interface UserInfo {
-    id: string;
-    name?: string;
-    roles?: string[];
-}
-export declare type Allowed = boolean | string | string[] | ((c?: Remult) => boolean);
-export declare type AllowedForInstance<T> = boolean | string | string[] | ((entity?: T, c?: Remult) => boolean);
-export declare class Allow {
-    static everyone: () => boolean;
-    static authenticated: (...args: any[]) => any;
-}
-export declare const queryConfig: {
-    defaultPageSize: number;
-};
-export interface EventDispatcher {
-    observe(what: () => any | Promise<any>): Promise<Unsubscribe>;
-}
-export declare class EventSource {
-    listeners: (() => {})[];
-    fire(): Promise<void>;
-    dispatcher: EventDispatcher;
-}
-export interface itemChange {
-    id: any;
-    oldId: any;
-    deleted: boolean;
-}
-export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;