remult 0.14.7 → 0.14.10

package/esm/server/register-actions-on-server.js

@@ -0,0 +1,24 @@
+import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
+export function registerActionsOnServer(area, controllers) {
+    var addAction = (a) => {
+        let x = a[serverActionField];
+        if (!x) {
+            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
+        }
+        area.addAction(x);
+    };
+    actionInfo.runningOnServer = true;
+    if (controllers && controllers.length > 0) {
+        for (const c of controllers) {
+            let z = c[classBackendMethodsArray];
+            if (z)
+                for (const a of z) {
+                    addAction(a);
+                }
+        }
+    }
+    else
+        actionInfo.allActions.forEach((a) => {
+            addAction(a);
+        });
+}

package/esm/server/register-entities-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerEntitiesOnServer(area: SiteArea, entities?: ClassType<any>[]): void;

package/esm/server/register-entities-on-server.js

@@ -0,0 +1,15 @@
+import { getEntityKey } from "../src/remult3";
+import { allEntities } from "../src/context";
+import { DataApi } from "../src/data-api";
+export function registerEntitiesOnServer(area, entities) {
+    if (!entities)
+        entities = allEntities;
+    //add Api Entries
+    entities.forEach(e => {
+        let key = getEntityKey(e);
+        if (key != undefined)
+            area.add(key, c => {
+                return new DataApi(c.repo(e), c);
+            });
+    });
+}

package/esm/src/__EntityValueProvider.d.ts

@@ -0,0 +1,10 @@
+export interface packedRowInfo {
+    data: any;
+    isNewRow: boolean;
+    id: string;
+    wasChanged: boolean;
+}
+export interface entityEventListener<entityType> {
+    deleted?: (entity: entityType) => void;
+    validating?: (entity: entityType) => Promise<any> | any;
+}

package/esm/src/__EntityValueProvider.js

@@ -0,0 +1 @@
+export {};

package/esm/src/__RowsOfDataForTesting.d.ts

@@ -0,0 +1,3 @@
+export interface __RowsOfDataForTesting {
+    rows: any;
+}

package/esm/src/__RowsOfDataForTesting.js

@@ -0,0 +1 @@
+export {};

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -0,0 +1,5 @@
+import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
+export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+import '../shared-tests';

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -0,0 +1,113 @@
+import { Remult } from "../context";
+import { KnexDataProvider, KnexSchemaBuilder } from '../../remult-knex';
+import * as Knex from 'knex';
+import { MongoClient } from 'mongodb';
+import { config } from 'dotenv';
+import { createPostgresConnection, PostgresSchemaBuilder } from "../../postgres";
+import { addDatabaseToTest, itWithFocus, testAll } from "../shared-tests/db-tests-setup";
+config();
+function testKnexSqlImpl(knex, name) {
+    return (key, what, focus = false) => {
+        itWithFocus(key + " " + name + " - knex", async () => {
+            let db = new KnexDataProvider(knex);
+            let remult = new Remult(db);
+            await what({
+                db, remult,
+                createEntity: async (entity) => {
+                    let repo = remult.repo(entity);
+                    let sb = new KnexSchemaBuilder(knex);
+                    await knex.schema.dropTableIfExists(await repo.metadata.getDbName());
+                    await sb.createIfNotExist(repo.metadata);
+                    await sb.verifyAllColumns(repo.metadata);
+                    await knex(await repo.metadata.getDbName()).delete();
+                    return repo;
+                }
+            });
+        }, focus);
+    };
+}
+export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
+    client: 'pg',
+    connection: process.env.DATABASE_URL,
+}), "postgres");
+addDatabaseToTest(testKnexPGSqlImpl);
+if (process.env['TESTS_SQL_SERVER'])
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+        client: 'mssql',
+        connection: {
+            server: '127.0.0.1',
+            database: 'test2',
+            user: 'sa',
+            password: 'MASTERKEY',
+            options: {
+                enableArithAbort: true,
+                encrypt: false,
+                instanceName: 'sqlexpress'
+            }
+        } //,debug: true
+    }), "sql server"));
+if (true)
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+        client: 'better-sqlite3',
+        connection: {
+            filename: ":memory:"
+        },
+    }), "sqlite3"));
+let pg = createPostgresConnection({
+    autoCreateTables: false
+});
+export function testPostgresImplementation(key, what, focus = false) {
+    itWithFocus(key + " - postgres", async () => {
+        let db = await pg;
+        let remult = new Remult(db);
+        await what({
+            db, remult,
+            createEntity: async (entity) => {
+                let repo = remult.repo(entity);
+                let sb = new PostgresSchemaBuilder(db);
+                await db.execute("drop table if exists " + await repo.metadata.getDbName());
+                await sb.createIfNotExist(repo.metadata);
+                await sb.verifyAllColumns(repo.metadata);
+                await db.execute("delete from " + await repo.metadata.getDbName());
+                return repo;
+            }
+        });
+    }, focus);
+}
+addDatabaseToTest(testPostgresImplementation);
+import { Categories } from "../tests/remult-3-entities";
+import { MongoDataProvider } from "../../remult-mongo";
+testAll("transactions", async ({ db, createEntity }) => {
+    let x = await createEntity(Categories);
+    await db.transaction(async (db) => {
+        let remult = new Remult(db);
+        expect(await remult.repo(Categories).count()).toBe(0);
+    });
+});
+let client = new MongoClient("mongodb://localhost:27017/local");
+let done;
+let mongoDbPromise = client.connect().then(c => {
+    done = c;
+    return c.db("test");
+});
+afterAll(async () => {
+    if (done)
+        done.close();
+});
+export function testMongo(key, what, focus = false) {
+    itWithFocus(key + " - mongo", async () => {
+        let mongoDb = await mongoDbPromise;
+        let db = new MongoDataProvider(mongoDb, client);
+        let remult = new Remult(db);
+        await what({
+            db, remult,
+            createEntity: async (entity) => {
+                let repo = remult.repo(entity);
+                await mongoDb.collection(await repo.metadata.getDbName()).deleteMany({});
+                return repo;
+            }
+        });
+    }, focus);
+}
+addDatabaseToTest(testMongo);
+import '../shared-tests';

package/esm/src/backend-tests/my-test.backend-spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/backend-tests/my-test.backend-spec.js

@@ -0,0 +1,49 @@
+import { KnexDataProvider } from '../../remult-knex';
+import { config } from 'dotenv';
+import { testKnexPGSqlImpl, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
+import { entityWithValidations } from "../shared-tests/entityWithValidations";
+import { SqlDatabase } from "../data-providers/sql-database";
+config();
+testPostgresImplementation("sql filter", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: SqlDatabase.customFilter(async (build) => {
+            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+        })
+    })).length).toBe(2);
+}, false);
+testPostgresImplementation("sql filter2", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: {
+            $or: [
+                SqlDatabase.customFilter(async (build) => {
+                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                }),
+                {
+                    myId: 2
+                }
+            ]
+        }
+    })).length).toBe(3);
+}, false);
+testKnexPGSqlImpl("knex filter", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: KnexDataProvider.customFilter(async () => {
+            return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
+        })
+    })).length).toBe(2);
+}, false);
+testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({
+        where: {
+            $or: [KnexDataProvider.customFilter(async () => {
+                    return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
+                }), {
+                    myId: 4
+                }]
+        }
+    })).length).toBe(3);
+}, false);

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

@@ -0,0 +1,95 @@
+import { ClassType } from '../classType';
+import { Allowed, AllowedForInstance } from './context';
+import { EntityMetadata, FieldRef } from './remult3';
+export interface FieldOptions<entityType = any, valueType = any> {
+    /**A human readable name for the field */
+    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, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    /** Will be fired before this field is saved to the server/database */
+    saving?: ((entity: entityType, col: 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 */
+    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;
+}
+export interface FieldMetadata<valueType = any> {
+    readonly key: string;
+    readonly target: ClassType<valueType>;
+    readonly valueType: any;
+    readonly caption: string;
+    readonly inputType: string;
+    readonly allowNull: boolean;
+    getDbName(): Promise<string>;
+    readonly isServerExpression: boolean;
+    readonly dbReadOnly: boolean;
+    readonly valueConverter: ValueConverter<valueType>;
+    readonly options: FieldOptions;
+}
+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, col: 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/src/column-interfaces.js

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

package/esm/src/column.d.ts

@@ -0,0 +1,49 @@
+import { ClassType } from '../classType';
+import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
+import { Filter } from './filter/filter-interfaces';
+import { EntityFilter, FindOptions, Repository, RepositoryImplementation } from './remult3';
+export declare function makeTitle(name: string): string;
+export declare class CompoundIdField implements FieldMetadata<string> {
+    fields: FieldMetadata[];
+    constructor(...columns: FieldMetadata[]);
+    getDbName(): Promise<string>;
+    getId(instance: any): string;
+    options: FieldOptions<any, any>;
+    get valueConverter(): 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: string;
+    setId(val: any): void;
+    waitLoadOf(id: any): Promise<T>;
+    get(id: any): any;
+    set(item: T): void;
+    constructor(repository: RepositoryImplementation<T>, id: string);
+    get item(): T;
+    waitLoad(): Promise<T>;
+}
+export declare class OneToMany<T> {
+    private provider;
+    private settings?;
+    constructor(provider: Repository<T>, settings?: {
+        create?: (newItem: T) => void;
+    } & FindOptions<T>);
+    private _items;
+    private _currentPromise;
+    get lazyItems(): T[];
+    load(): Promise<T[]>;
+    private find;
+    create(item?: Partial<T>): T;
+}

package/esm/src/column.js

@@ -0,0 +1,133 @@
+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 {
+    constructor(...columns) {
+        this.fields = columns;
+    }
+    getDbName() {
+        return Promise.resolve("");
+    }
+    getId(instance) {
+        let r = "";
+        this.fields.forEach(c => {
+            if (r.length > 0)
+                r += ',';
+            r += instance[c.key];
+        });
+        return r;
+    }
+    get valueConverter() {
+        throw new Error("cant get value converter of compound id");
+    }
+    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 {
+    constructor(repository, id) {
+        this.repository = repository;
+        this.id = id;
+    }
+    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);
+    }
+    set(item) {
+        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.id = item[this.repository.metadata.idMetadata.field.key];
+                }
+            }
+        }
+        else if (item === null) {
+            this.id = null;
+        }
+        else {
+            this.id = undefined;
+        }
+    }
+    get item() {
+        return this.get(this.id);
+    }
+    async waitLoad() {
+        return this.waitLoadOf(this.id);
+    }
+}
+9000;
+export class OneToMany {
+    constructor(provider, settings) {
+        this.provider = provider;
+        this.settings = settings;
+    }
+    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/src/context.d.ts

@@ -0,0 +1,124 @@
+import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
+import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
+import { ClassType } from "../classType";
+export interface HttpProvider {
+    post(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    delete(url: string): Promise<void> | {
+        toPromise(): Promise<void>;
+    };
+    put(url: string, data: any): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+    get(url: string): Promise<any> | {
+        toPromise(): Promise<any>;
+    };
+}
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: HttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
+export declare function toPromise<T>(p: Promise<T> | {
+    toPromise(): Promise<T>;
+}): Promise<any>;
+export declare function processHttpException(ex: any): Promise<any>;
+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)
+     *
+     */
+    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Returns the current user's info */
+    get user(): UserInfo;
+    /** Set's the current user info */
+    setUser(info: UserInfo | {
+        sub?: string;
+        name?: string;
+        permissions?: string[];
+        username?: string;
+    }): Promise<void>;
+    private _user;
+    private _userChangeEvent;
+    /** 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;
+    /** returns a dispatcher object that fires once a user has changed*/
+    get userChange(): EventDispatcher;
+    private repCache;
+    /** 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(provider?: HttpProvider | DataProvider);
+    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
+     *
+     * Set this property in case you want to determine a non relative api url
+     */
+    static apiBaseUrl: string;
+    /** The current data provider */
+    _dataSource: DataProvider;
+    /** sets the current data provider */
+    setDataProvider(dataProvider: DataProvider): void;
+    /** 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;
+}
+export declare const allEntities: ClassType<any>[];
+export interface ControllerOptions {
+    key: string;
+}
+export declare const classHelpers: Map<any, ClassHelper>;
+export declare class ClassHelper {
+    methods: MethodHelper[];
+}
+export declare class MethodHelper {
+    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[] | ((c: Remult, entity?: T) => boolean);
+export declare class Allow {
+    static everyone: () => boolean;
+    static authenticated: (remult: Remult) => boolean;
+}
+export declare const queryConfig: {
+    defaultPageSize: number;
+};
+export interface EventDispatcher {
+    observe(what: () => any | Promise<any>): Promise<Unobserve>;
+}
+export declare type Unobserve = () => void;
+export declare class EventSource {
+    listeners: (() => {})[];
+    fire(): Promise<void>;
+    dispatcher: EventDispatcher;
+}