remult 0.18.1-exp.4 → 0.18.1-exp.6

package/esm/index.d.ts

@@ -1,6 +1,6 @@
-export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, InferMemberType, InferredType, MemberType as TypedDecorator, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
-export { describeClass, createEntity, createClass } from './src/remult3/DecoratorReplacer';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
 export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
+export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
 export { SqlCommand, SqlImplementation, SqlResult } from './src/sql-command';
@@ -13,7 +13,7 @@ export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
 export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
-export { Controller, BackendMethodOptions, BackendMethod, ProgressListener, createBackendMethod, CreateBackendMethodOptions, BackendMethodType, InferredMethodType, } from './src/server-action';
+export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
 export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { IdEntity } from './src/id-entity';
@@ -25,4 +25,4 @@ export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
-export { SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionClient';
+export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';

package/esm/index.js

@@ -2,7 +2,7 @@
  * Public API Surface of remult
  */
 export { Field, Fields, Entity, EntityBase, ControllerBase, FieldType, getFields, getEntityRef, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer } from './src/remult3';
-export { describeClass, createEntity, createClass } from './src/remult3/DecoratorReplacer';
+export { describeClass } from './src/remult3/DecoratorReplacer';
 export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider'; //V
@@ -11,7 +11,7 @@ export { SqlDatabase, } from './src/data-providers/sql-database'; //V
 export { CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider } from './src/data-providers/json-data-provider'; //V
 //export * from './src/data-api'; //reconsider if to make internal
-export { Controller, BackendMethod, ProgressListener, createBackendMethod, } from './src/server-action';
+export { Controller, BackendMethod, ProgressListener } from './src/server-action';
 export { Allow, Remult, isBackend, EventSource } from './src/context';
 export { IdEntity } from './src/id-entity';
 export { Sort } from './src/sort';
@@ -23,4 +23,4 @@ export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 //export { getId } from './src/remult3/getId';
 export { InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
-export { SubscriptionChannel } from './src/live-query/SubscriptionClient';
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel';

package/esm/live-query/ably.d.ts

@@ -1,6 +1,6 @@
 import type * as Ably from 'ably';
 import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
-import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionClient';
+import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
 export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);

package/esm/postgres/schema-builder.js

@@ -43,7 +43,8 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure"); //keep me
+        if (PostgresSchemaBuilder.logToConsole)
+            console.time("Postgres Auto create tables and columns");
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
             let e = await dbNamesOf(entity);
@@ -56,9 +57,11 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + e.$entityName + " ", err);
+                console.error("failed verify structure of " + e.$entityName + " ", err);
             }
         }
+        if (PostgresSchemaBuilder.logToConsole)
+            console.timeEnd("Postgres Auto create tables and columns");
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();
@@ -81,7 +84,8 @@ export class PostgresSchemaBuilder {
                     }
                 }
                 let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
-                //console.log(sql);
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
                 await this.pool.execute(sql);
             }
         });
@@ -97,7 +101,8 @@ export class PostgresSchemaBuilder {
         FROM information_schema.columns 
         WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.$entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
                 let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
-                //console.log(sql);
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
                 await this.pool.execute(sql);
             }
         }
@@ -116,7 +121,8 @@ export class PostgresSchemaBuilder {
                 if (!isDbReadonly(col, e))
                     if (!cols.includes(e.$dbNameOf(col).toLocaleLowerCase())) {
                         let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
-                        //console.log(sql);
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
                         await this.pool.execute(sql);
                     }
             }
@@ -126,3 +132,5 @@ export class PostgresSchemaBuilder {
         }
     }
 }
+//@internal
+PostgresSchemaBuilder.logToConsole = true;

package/esm/remult-express.js

@@ -1,6 +1,6 @@
 import * as express from 'express';
 import { createRemultServer } from './server/index';
-import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/SubscriptionClient';
+import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/SubscriptionChannel';
 import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
 import { getEntityKey } from './src/remult3';

package/esm/remult-knex/index.d.ts

@@ -6,7 +6,7 @@ import { FieldMetadata } from '../src/column-interfaces';
 export declare class KnexDataProvider implements DataProvider {
     knex: Knex;
     constructor(knex: Knex);
-    static getDb(remult?: Remult): Knex<any, Record<string, any>[]>;
+    static getDb(remult?: Remult): Knex<any, any[]>;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;

package/esm/remult-knex/index.js

@@ -277,7 +277,8 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.info("start verify structure");
+        if (KnexSchemaBuilder.logToConsole)
+            console.time("Knex Auto create tables and columns");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -289,9 +290,11 @@ export class KnexSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + await metadata.getDbName() + " ", err);
+                console.error("failed verify structure of " + await metadata.getDbName() + " ", err);
             }
         }
+        if (KnexSchemaBuilder.logToConsole)
+            console.timeEnd("Knex Auto create tables and columns");
     }
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity);
@@ -325,16 +328,16 @@ export class KnexSchemaBuilder {
         let col = c(entity);
         let colName = e.$dbNameOf(col);
         if (!await this.knex.schema.hasColumn(e.$entityName, colName)) {
-            await this.knex.schema.alterTable(e.$entityName, b => {
+            await logSql(this.knex.schema.alterTable(e.$entityName, b => {
                 buildColumn(col, colName, b);
-            });
+            }));
         }
     }
     async verifyAllColumns(entity) {
         let e = await dbNamesOf(entity);
         try {
-            for (const col of entity.fields) {
-                if (isDbReadonly(col, e)) {
+            for (const col of entity.fields.toArray()) {
+                if (!isDbReadonly(col, e)) {
                     await this.addColumnIfNotExist(entity, () => col);
                 }
             }
@@ -344,6 +347,8 @@ export class KnexSchemaBuilder {
         }
     }
 }
+//@internal
+KnexSchemaBuilder.logToConsole = true;
 export function buildColumn(x, dbName, b) {
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb) {
@@ -394,7 +399,8 @@ export function buildColumn(x, dbName, b) {
     }
 }
 function logSql(who) {
-    //console.log(who.toSQL().sql);
+    if (KnexSchemaBuilder.logToConsole)
+        console.info(who.toSQL());
     return who;
 }
 export async function createKnexDataProvider(config, autoCreateTables = true) {

package/esm/server/expressBridge.d.ts

@@ -1,6 +1,6 @@
 import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { EntityInfoProvider, Remult, UserInfo } from '../src/context';
+import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
@@ -14,7 +14,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     queueStorage?: QueueStorage;
     liveQueryStorage?: LiveQueryStorage;
     subscriptionServer?: SubscriptionServer;
-    initRequest?: (remult: Remult, origReq: RequestType, options: InitRequestOptions) => Promise<void>;
+    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
     requestSerializer?: {
         toJson: (request: RequestType) => any;
         fromJson: (request: any) => RequestType;
@@ -23,12 +23,13 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
-    entities?: (ClassType<any> | EntityInfoProvider<any>)[];
+    entities?: ClassType<any>[];
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
 export interface InitRequestOptions {
     liveQueryStorage: LiveQueryStorage;
+    readonly remult: Remult;
 }
 export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;

package/esm/server/expressBridge.js

@@ -217,7 +217,8 @@ export class RemultServerImplementation {
                             remult.user = (user);
                     }
                     if (this.options.initRequest) {
-                        await this.options.initRequest(remult, req, {
+                        await this.options.initRequest(req, {
+                            remult,
                             get liveQueryStorage() {
                                 return remult.liveQueryStorage;
                             },

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

@@ -2,7 +2,10 @@ 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 */
+    /** 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;
@@ -32,14 +35,23 @@ export interface FieldOptions<entityType = any, valueType = any> {
      *   }
      * })
      */
-    validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    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, col: FieldRef<entityType, valueType>) => (any | Promise<any>));
+    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 */
+    /** 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;
@@ -62,18 +74,42 @@ export interface FieldOptions<entityType = any, valueType = any> {
     /** 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> {
+    /** 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;
-    readonly target: ClassType<valueType>;
-    readonly valueType: any;
+    /** 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: ValueConverter<valueType>;
-    readonly options: FieldOptions;
 }
 export interface ValueConverter<valueType> {
     fromJson?(val: any): valueType;
@@ -86,7 +122,7 @@ export interface ValueConverter<valueType> {
     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 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 {

package/esm/src/column.d.ts

@@ -25,15 +25,12 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 }
 export declare class LookupColumn<T> {
     private repository;
-    private _id;
+    id: idType<T>;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, _id: idType<T>);
-    private _item;
-    get id(): any;
-    set id(value: any);
+    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/column.js

@@ -52,10 +52,9 @@ export class CompoundIdField {
     }
 }
 export class LookupColumn {
-    constructor(repository, _id) {
+    constructor(repository, id) {
         this.repository = repository;
-        this._id = _id;
-        this._item = undefined;
+        this.id = id;
     }
     setId(val) {
         if (this.repository.metadata.idMetadata.field.valueType == Number)
@@ -69,54 +68,39 @@ export class LookupColumn {
     }
     get(id) {
         if (id === undefined || id === null)
-            if (!this._item)
-                return null;
-            else
-                return this._item;
+            return null;
         return this.repository.getCachedById(id);
     }
     set(item) {
-        this._item = item;
         if (item) {
-            if (typeof item === "string" || typeof item === "number") {
-                this._id = item;
-                this._item = undefined;
-            }
+            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();
+                    this.id = eo.getId();
                 }
                 else {
-                    this._item = item;
-                    this._id = item[this.repository.metadata.idMetadata.field.key];
+                    this.id = item[this.repository.metadata.idMetadata.field.key];
                 }
             }
         }
         else if (item === null) {
-            this._id = null;
+            this.id = null;
         }
         else {
-            this._id = undefined;
+            this.id = undefined;
         }
     }
-    get id() {
-        return this._id;
-    }
-    set id(value) {
-        this._id = value;
-        this._item = undefined;
-    }
     get item() {
-        if (this._item)
-            return this._item;
-        return this.get(this._id);
+        return this.get(this.id);
     }
     async waitLoad() {
-        return this.waitLoadOf(this._id);
+        return this.waitLoadOf(this.id);
     }
 }
+9000;
 export class OneToMany {
     constructor(provider, settings) {
         this.provider = provider;

package/esm/src/context.d.ts

@@ -3,28 +3,18 @@ import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
 import type { SubscriptionServer } from "./live-query/SubscriptionServer";
 import { ExternalHttpProvider } from "./buildRestDataProvider";
-import { SubscriptionClient } from "./live-query/SubscriptionClient";
-import { EntityOptions } from "./entity";
-import { FieldOptions } from "./column-interfaces";
+import { SubscriptionClient } from "./live-query/SubscriptionChannel";
 export declare function isBackend(): boolean;
-export interface EntityInfoProvider<InstanceType> {
-    $entity$key: string;
-    $entity$getInfo(remult: Remult): EntityInfo<InstanceType>;
-}
-export interface EntityInfo<instanceType> {
-    options: EntityOptions;
-    fields: FieldOptions[];
-    createInstance?(remult: Remult): instanceType;
-    entityType?: any;
-}
 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> | EntityInfoProvider<T>), dataProvider?: DataProvider): Repository<T>;
+    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;
@@ -40,6 +30,8 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
+    /** The current data provider */
+    dataProvider: DataProvider;
     /** 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.
@@ -50,22 +42,38 @@ export declare class Remult {
     constructor(p: DataProvider);
     constructor();
     subscriptionServer?: SubscriptionServer;
+    /** 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>;
-    /** The current data provider */
-    dataProvider: DataProvider;
     /** 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;
 }
 export declare 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;
@@ -84,11 +92,11 @@ export interface UserInfo {
     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 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: (remult: Remult) => boolean;
+    static authenticated: (...args: any[]) => any;
 }
 export declare const queryConfig: {
     defaultPageSize: number;

package/esm/src/context.js

@@ -1,6 +1,6 @@
 import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider } from './data-providers/rest-data-provider';
-import { createOldEntity, decorateColumnSettings, EntityFullInfo, getEntityKey, RepositoryImplementation } from "./remult3/RepositoryImplementation";
+import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 import { LiveQueryClient } from "./live-query/LiveQueryClient";
 import { SseSubscriptionClient } from "./live-query/SseSubscriptionClient";
 import { RemultProxy } from "./remult-proxy";
@@ -10,17 +10,19 @@ export function isBackend() {
 }
 export class Remult {
     constructor(provider) {
+        /** The current data provider */
+        this.dataProvider = new RestDataProvider(() => this.apiClient);
         /* @internal */
         this.repCache = new Map();
         /* @internal*/
         this.liveQueryPublisher = {
             itemChanged: () => { }
         };
-        /** The current data provider */
-        this.dataProvider = new RestDataProvider(() => this.apiClient);
         /* @internal*/
         this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient);
+        /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
         this.context = {};
+        /** The api client that will be used by `remult` to perform calls to the `api` */
         this.apiClient = {
             url: '/api',
             subscriptionClient: new SseSubscriptionClient()
@@ -50,7 +52,8 @@ export class Remult {
      * @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(entity, dataProvider) {
         if (dataProvider === undefined)
@@ -60,18 +63,10 @@ export class Remult {
             this.repCache.set(dataProvider, dpCache = new Map());
         let r = dpCache.get(entity);
         if (!r) {
-            const z = entity;
-            if (z.$entity$getInfo) {
-                let info = z.$entity$getInfo(this);
-                info.fields.forEach(f => decorateColumnSettings(f, this));
-                dpCache.set(entity, r = new RepositoryImplementation(new EntityFullInfo(info, getEntityKey(z), this), this, dataProvider));
-            }
-            else
-                dpCache.set(entity, r = new RepositoryImplementation(createOldEntity(entity, this), this, dataProvider));
+            dpCache.set(entity, r = new RepositoryImplementation(entity, this, dataProvider));
         }
         return r;
     }
-    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
         return this.user?.id !== undefined;
@@ -117,12 +112,19 @@ export class Remult {
             }
         }
         else if (typeof (allowed) === "function") {
-            return allowed(this, instance);
+            return allowed(instance, this);
         }
         else
             return this.isAllowed(allowed);
     }
     //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
+    /** 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(backendMethod, classInstance, ...args) {
         const z = (backendMethod[serverActionField]);
         if (!z.doWork)
@@ -161,7 +163,16 @@ export function setControllerSettings(target, options) {
 export class Allow {
 }
 Allow.everyone = () => true;
-Allow.authenticated = (remult) => remult.authenticated();
+Allow.authenticated = (...args) => {
+    if (args.length > 1) {
+        return args[1].authenticated();
+    }
+    else if (args.length == 1) {
+        if (args[0].authenticated)
+            return args[0].authenticated();
+    }
+    return RemultProxy.defaultRemult.authenticated();
+};
 export const queryConfig = {
     defaultPageSize: 200
 };

package/esm/src/data-api.js

@@ -200,8 +200,8 @@ export class DataApi {
                 response.forbidden();
                 return;
             }
-            await this.repository.getEntityRef(row).save();
-            response.success(this.repository.getEntityRef(row).toApiJson());
+            await ref.save();
+            response.success(ref.toApiJson());
         });
     }
     async delete(response, id) {

package/esm/src/data-providers/rest-data-provider.js

@@ -225,7 +225,7 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
             const element = filter[key];
             if (Array.isArray(element)) {
-                if (key.endsWith("_in"))
+                if (key.endsWith(".in"))
                     url.add(key, JSON.stringify(element));
                 else
                     element.forEach(e => url.add(key, e));