remult 0.24.0 → 0.24.1

package/esm/src/server-action.d.ts

@@ -1,79 +0,0 @@
-import 'reflect-metadata';
-import type { AllowedForInstance } from './context';
-import { Remult } from './context';
-import type { DataApiResponse } from './data-api';
-import type { DataProvider, RestDataProviderHttpProvider } from './data-interfaces';
-interface inArgs {
-    args: any[];
-}
-interface result {
-    data: any;
-}
-export declare abstract class Action<inParam, outParam> implements ActionInterface {
-    private actionUrl;
-    private queue;
-    private allowed;
-    constructor(actionUrl: string, queue: boolean, allowed: AllowedForInstance<any>);
-    static apiUrlForJobStatus: string;
-    run(pIn: inParam, baseUrl?: string, http?: RestDataProviderHttpProvider): Promise<outParam>;
-    doWork: (args: any[], self: any, baseUrl?: string, http?: RestDataProviderHttpProvider) => Promise<any>;
-    protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
-    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: (data: any, req: Remult, res: DataApiResponse) => void) => void): void;
-}
-export declare class ForbiddenError extends Error {
-    constructor();
-    isForbiddenError: true;
-}
-export declare class myServerAction extends Action<inArgs, result> {
-    private types;
-    private options;
-    originalMethod: (args: any[]) => any;
-    constructor(name: string, types: any[], options: BackendMethodOptions<any>, originalMethod: (args: any[]) => any);
-    protected execute(info: inArgs, remult: Remult, res: DataApiResponse): Promise<result>;
-}
-export interface BackendMethodOptions<type> {
-    /**Determines when this `BackendMethod` can execute, see: [Allowed](https://remult.dev/docs/allowed.html)  */
-    allowed: AllowedForInstance<type>;
-    /** Used to determine the route for the BackendMethod.
-     * @example
-     * {allowed:true, apiPrefix:'someFolder/'}
-     */
-    apiPrefix?: string;
-    /** EXPERIMENTAL: Determines if this method should be queued for later execution */
-    queue?: boolean;
-    /** EXPERIMENTAL: Determines if the user should be blocked while this `BackendMethod` is running*/
-    blockUser?: boolean;
-    paramTypes?: any[];
-}
-export declare function Controller(key: string): (target: any, context?: any) => any;
-export interface ClassMethodDecoratorContextStub<This = unknown, Value extends (this: This, ...args: any) => any = (this: This, ...args: any) => any> {
-    readonly kind: 'method';
-    readonly name: string | symbol;
-    readonly access: {
-        has(object: This): boolean;
-    };
-}
-/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
-export declare function BackendMethod<type = any>(options: BackendMethodOptions<type>): (target: any, context: ClassMethodDecoratorContextStub<type> | string, descriptor?: any) => any;
-export interface jobWasQueuedResult {
-    queuedJobId?: string;
-}
-export interface queuedJobInfoResponse {
-    done: boolean;
-    result?: any;
-    error?: any;
-    progress?: number;
-}
-export declare class ProgressListener {
-    private res;
-    constructor(res: DataApiResponse);
-    progress(progress: number): void;
-}
-export declare function prepareArgsToSend(types: any[], args: any[]): any[];
-export declare function prepareReceivedArgs(types: any[], args: any[], remult: Remult, ds: DataProvider, res: DataApiResponse): Promise<any[]>;
-export declare const classBackendMethodsArray: unique symbol;
-export interface ActionInterface {
-    doWork: (args: any[], self: any, baseUrl?: string, http?: RestDataProviderHttpProvider) => Promise<any>;
-    __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: (data: any, req: Remult, res: DataApiResponse) => void) => void): any;
-}
-export {};

package/esm/src/sort.d.ts

@@ -1,16 +0,0 @@
-import type { FieldMetadata } from './column-interfaces';
-import type { EntityMetadata, EntityOrderBy } from './remult3/remult3';
-export declare class Sort {
-    toEntityOrderBy(): EntityOrderBy<any>;
-    constructor(...segments: SortSegment[]);
-    Segments: SortSegment[];
-    reverse(): Sort;
-    compare(a: any, b: any, getFieldKey?: (field: FieldMetadata) => string): number;
-    static translateOrderByToSort<T>(entityDefs: EntityMetadata<T>, orderBy?: EntityOrderBy<T>): Sort;
-    static createUniqueSort<T>(entityMetadata: EntityMetadata<T>, orderBy?: Sort): Sort;
-    static createUniqueEntityOrderBy<T>(entityMetadata: EntityMetadata<T>, orderBy?: EntityOrderBy<T>): EntityOrderBy<T>;
-}
-export interface SortSegment {
-    field: FieldMetadata;
-    isDescending?: boolean;
-}

package/esm/src/sql-command.d.ts

@@ -1,19 +0,0 @@
-import type { EntityMetadata } from './remult3/remult3';
-export interface SqlImplementation {
-    getLimitSqlSyntax(limit: number, offset: number): any;
-    createCommand(): SqlCommand;
-    transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
-    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
-    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
-    supportsJsonColumnType?: boolean;
-}
-export interface SqlCommand extends SqlCommandWithParameters {
-    execute(sql: string): Promise<SqlResult>;
-}
-export interface SqlCommandWithParameters {
-    addParameterAndReturnSqlToken(val: any): string;
-}
-export interface SqlResult {
-    rows: any[];
-    getColumnKeyInResultForIndexInSelect(index: number): string;
-}

package/esm/src/validators.d.ts

@@ -1,14 +0,0 @@
-import type { FieldRef } from './remult3/remult3';
-export declare class Validators {
-    static required: ((entity: any, col: FieldRef<any, string>, message?: any) => void) & {
-        withMessage: (message: string) => (entity: any, col: FieldRef<any, string>) => void;
-        defaultMessage: string;
-    };
-    static unique: ((entity: any, col: FieldRef<any, any>, message?: any) => Promise<void>) & {
-        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
-        defaultMessage: string;
-    };
-    static uniqueOnBackend: ((entity: any, col: FieldRef<any, any>, message?: any) => Promise<void>) & {
-        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
-    };
-}

package/esm/src/valueConverters.d.ts

@@ -1,13 +0,0 @@
-import type { ValueConverter } from './column-interfaces';
-export declare class ValueConverters {
-    static readonly Date: ValueConverter<Date>;
-    static readonly DateOnly: ValueConverter<Date>;
-    static readonly DateOnlyString: ValueConverter<Date>;
-    static readonly Boolean: ValueConverter<Boolean>;
-    static readonly Number: ValueConverter<number>;
-    static readonly String: ValueConverter<String>;
-    static readonly Integer: ValueConverter<number>;
-    static readonly Default: Required<ValueConverter<any>>;
-    static readonly JsonString: ValueConverter<any>;
-    static readonly JsonValue: ValueConverter<any>;
-}

package/esm/urlBuilder.d.ts

@@ -1,6 +0,0 @@
-export declare class UrlBuilder {
-    url: string;
-    constructor(url: string);
-    add(key: string, value: any): void;
-    addObject(object: any, suffix?: string): void;
-}