remult 0.24.0-exp.4 → 0.24.0

package/esm/postgres/index.d.ts

@@ -1,2 +1,2 @@
-export { PostgresDataProvider, PostgresPool, preparePostgresQueueStorage, PostgresClient, createPostgresConnection, createPostgresDataProvider, PostgresCommandSource, } from './postgres-data-provider';
-export { PostgresSchemaBuilder, postgresColumnSyntax } from './schema-builder';
+export * from './postgres-data-provider';
+export * from './schema-builder';

package/esm/postgres/postgres-data-provider.d.ts

@@ -11,37 +11,26 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
-    private options?;
     supportsJsonColumnType: boolean;
     static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;
-    constructor(pool: PostgresPool, options?: {
-        wrapIdentifier?: (name: string) => string;
-        schema?: string;
-    });
-    wrapIdentifier: (name: any) => any;
+    constructor(pool: PostgresPool);
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
     query(queryText: string, values?: any[]): Promise<QueryResult>;
 }
-export declare function createPostgresConnection(options?: Parameters<typeof createPostgresDataProvider>[0]): Promise<SqlDatabase>;
+export declare function createPostgresConnection(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: 'heroku' | PoolConfig;
+}): Promise<SqlDatabase>;
 export declare function createPostgresDataProvider(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: 'heroku' | PoolConfig;
-    wrapIdentifier?: (name: string) => string;
-    caseInsensitiveIdentifiers?: boolean;
-    schema?: string;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;
-export declare class PostgresSchemaWrapper implements PostgresPool {
-    private pool;
-    private schema;
-    constructor(pool: PostgresPool, schema: string);
-    connect(): Promise<PostgresClient>;
-    query(queryText: string, values?: any[]): Promise<QueryResult>;
-}

package/esm/remult-nuxt.js

@@ -1,5 +1,5 @@
-import { readBody } from 'h3';
-import { createRemultServer, } from './server/index.js';
+import { readBody, setResponseStatus } from 'h3';
+import { createRemultServer } from './server/index.js';
 export function remultNuxt(options) {
     const result = createRemultServer(options, {
         buildGenericRequestInfo: (event) => {
@@ -36,14 +36,16 @@ export function remultNuxt(options) {
             });
         }
         if (r) {
+            if (r.statusCode !== 200)
+                setResponseStatus(event, r.statusCode);
             return r.data;
         }
     };
     return Object.assign(handler, {
         getRemult: (req) => result.getRemult(req),
         openApiDoc: (options) => result.openApiDoc(options),
-        withRemult(event, what) {
-            return result.withRemultAsync(event, what);
+        withRemult(request, what) {
+            return result.withRemultAsync(request, what);
         },
     });
 }

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

@@ -120,8 +120,7 @@ export interface FieldMetadata<valueType = any, entityType = any> {
      * Task == taskRepo.metadata.fields.title.target //will return true
      */
     readonly target: ClassType<valueType>;
-    /**
-     * @deprecated Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
+    /** 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;

package/esm/src/data-api.d.ts

@@ -14,6 +14,7 @@ export declare class DataApi<T = any> {
         r: any[];
         findOptions: FindOptions<T>;
     }>;
+    private includeNone;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
     liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;

package/esm/src/data-providers/sql-database.d.ts

@@ -1,7 +1,7 @@
 import type { DataProvider, EntityDataProvider } from '../data-interfaces';
 import type { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from '../sql-command';
 import type { Remult } from '../context';
-import type { CustomSqlFilterBuilderFunction, EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request';
+import type { CustomSqlFilterBuilderFunction } from '../filter/filter-consumer-bridge-to-sql-request';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 import type { RepositoryOverloads } from '../remult3/RepositoryImplementation';
 export declare class SqlDatabase implements DataProvider {
@@ -9,12 +9,11 @@ export declare class SqlDatabase implements DataProvider {
     static getDb(remult?: Remult): SqlDatabase;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
-    wrapIdentifier: (name: string) => string;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters, dbNames?: EntityDbNamesBase): Promise<string>;
+    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
     /**
      * `false` _(default)_ - No logging
      *

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -1,6 +1,6 @@
 import type { FieldMetadata } from '../column-interfaces';
 import type { EntityMetadataOverloads, RepositoryOverloads } from '../remult3/RepositoryImplementation';
-import type { EntityFilter, EntityMetadata, MembersOnly } from '../remult3/remult3';
+import type { EntityFilter, MembersOnly } from '../remult3/remult3';
 import type { SqlCommandWithParameters } from '../sql-command';
 import type { Filter, FilterConsumer } from './filter-interfaces';
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
@@ -48,6 +48,4 @@ export declare type EntityDbNamesBase = {
 export declare type EntityDbNames<entityType> = {
     [Properties in keyof Required<MembersOnly<entityType>>]: string;
 } & EntityDbNamesBase;
-export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>, wrapIdentifier?: (name: string) => string): Promise<EntityDbNames<entityType>>;
-export declare function entityDbName(metadata: EntityMetadata, wrapIdentifier?: (name: string) => string): Promise<string>;
-export declare function fieldDbName(f: FieldMetadata, meta: EntityMetadata, wrapIdentifier?: (name: string) => string): Promise<string>;
+export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>): Promise<EntityDbNames<entityType>>;

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

@@ -1,5 +1,5 @@
 import type { FieldMetadata } from '../column-interfaces';
-import type { Remult } from '../context';
+import { Remult } from '../context';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class Filter {
     private apply;

package/esm/src/remult3/Fields.js

@@ -142,6 +142,7 @@ export class Relations {
                 ? {}
                 : options);
         if (!op.field && !op.fields && !op.findOptions)
+            //@ts-ignore
             return Field(toEntityType, {
                 ...op,
                 //@ts-ignore

package/esm/src/remult3/RepositoryImplementation.d.ts

@@ -180,9 +180,9 @@ export declare class FieldRefImplementation<entityType, valueType> implements Fi
     validate(): Promise<boolean>;
 }
 export declare const CaptionTransformer: {
-    transformCaption: (remult: Remult, key: string, caption: string, entityMetaData: EntityMetadata<any>) => string;
+    transformCaption: (remult: Remult, key: string, caption: string) => string;
 };
-export declare function buildCaption(caption: string | ((remult: Remult) => string), key: string, remult: Remult, metaData: EntityMetadata<any>): string;
+export declare function buildCaption(caption: string | ((remult: Remult) => string), key: string, remult: Remult): string;
 export declare class columnDefsImpl implements FieldMetadata {
     private settings;
     private entityDefs;
@@ -200,6 +200,7 @@ export declare class columnDefsImpl implements FieldMetadata {
     valueConverter: Required<ValueConverter<any>>;
     allowNull: boolean;
     caption: string;
+    get dbName(): any;
     inputType: string;
     key: string;
     get dbReadOnly(): boolean;
@@ -219,6 +220,7 @@ declare class EntityFullInfo<T> implements EntityMetadata<T> {
     apiDeleteAllowed(item: T): boolean;
     apiInsertAllowed(item: T): boolean;
     getEntityMetadataWithoutBreakingTheEntity(item: T): EntityRef<T>;
+    dbNamePromise: Promise<string>;
     getDbName(): Promise<string>;
     idMetadata: IdMetadata<T>;
     fields: FieldsMetadata<T>;

package/esm/src/remult3/RepositoryImplementation.js

@@ -177,11 +177,21 @@ export class RepositoryImplementation {
         return x;
     }
     async delete(item) {
+        const ref = getEntityRef(item, false);
+        if (ref)
+            return ref.delete();
         if (typeof item === 'string' || typeof item === 'number')
-            return this.edp.delete(item);
-        else {
-            return this.getRefForExistingRow(item, undefined).delete();
-        }
+            if (this.dataProvider.isProxy)
+                return this.edp.delete(item);
+            else {
+                let ref2 = await this.findId(item);
+                if (ref2)
+                    return await getEntityRef(ref2).delete();
+            }
+        let ref2 = this.getRefForExistingRow(item, undefined);
+        if (!this.dataProvider.isProxy)
+            await ref2.reload();
+        return ref2.delete();
     }
     async insert(entity) {
         if (Array.isArray(entity)) {

package/esm/src/remult3/remult3.d.ts

@@ -211,8 +211,7 @@ export interface EntityMetadata<entityType = any> {
      * }
      */
     apiInsertAllowed(item?: entityType): boolean;
-    /**
-     * @deprecated Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
     /** Metadata for the Entity's id */
     readonly idMetadata: IdMetadata<entityType>;

package/esm/src/remult3/remult3.js

@@ -7,11 +7,13 @@ export {};
 //p1 - v - add schema option to create postgres data provider
 /*p1 - V -  with remult async for remultexpress
 //y1 - lint tests (reference to js)
+//p1 - V Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
+//p1 - V Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
 //p1 - V withRemult function Add a with remult to Remult! - there is an existing one called Remult.run
 //p1 - V -  dbname to metadata consider making dbname in the field metadata options - non optional, so it'll be clear that it always have value - something like require the specific key - or move it to the metadata field
 //p1 - V - getEntityRefClone  What I would like is to make a copy of the item (without getting it from the server again)
 //p1 - V find one i had a question about find first's different syntax from find that confused a user
-
+//p1 - https://dexie.org/
 rename V - withremultpromise to that withRemultAsync
 expose live query storage in remult
 
@@ -62,8 +64,6 @@ remult.apiClient.url='localhost:3007/api
 //y2 - discuss a default date formatter
 //y2 - add some api testing framework for user unit tests (will help with codesandbox based discussions)
 //y2 - live query refresh of view on table update
-//y2 - Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
-//y2 - Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
 //y2 - livequery for findfirst (@JY)
 //y2 - #239 - (@JY) add a way to get from fieldMetadata back to entity repo (like we have in fieldRef)
 //p2 - constraints (@JY)

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

@@ -6,7 +6,6 @@ export interface SqlImplementation {
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     ensureSchema?(entities: EntityMetadata[]): Promise<void>;
     supportsJsonColumnType?: boolean;
-    wrapIdentifier?(name: string): string;
 }
 export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.24.0-exp.4",
+    "version": "0.24.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-nuxt.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-import { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
+import type { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
 export declare function remultNuxt(options: RemultServerOptions<H3Event>): RemultNuxtServer;
 export type RemultNuxtServer = RemultServerCore<H3Event> & ((event: H3Event) => Promise<any>) & {
     withRemult: RemultServer<H3Event>['withRemultAsync'];

package/remult-nuxt.js

@@ -57,6 +57,8 @@ function remultNuxt(options) {
                     _a.label = 3;
                 case 3:
                     if (r) {
+                        if (r.statusCode !== 200)
+                            (0, h3_1.setResponseStatus)(event, r.statusCode);
                         return [2 /*return*/, r.data];
                     }
                     return [2 /*return*/];
@@ -66,8 +68,8 @@ function remultNuxt(options) {
     return Object.assign(handler, {
         getRemult: function (req) { return result.getRemult(req); },
         openApiDoc: function (options) { return result.openApiDoc(options); },
-        withRemult: function (event, what) {
-            return result.withRemultAsync(event, what);
+        withRemult: function (request, what) {
+            return result.withRemultAsync(request, what);
         },
     });
 }

package/src/remult3/Fields.d.ts

@@ -10,9 +10,9 @@ export declare class Fields {
     static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
     static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
-    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
-    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
-    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, number> | ((options: FieldOptions<entityType, number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, number> | ((options: FieldOptions<entityType, number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static number<entityType = any>(...options: (FieldOptions<entityType, number> | ((options: FieldOptions<entityType, number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
     static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
@@ -126,7 +126,7 @@ export declare class Relations {
  * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
-export declare function Field<entityType = any, valueType = any>(valueType: (() => ClassType<valueType>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export declare function Field<entityType = any, valueType = any>(valueType: (() => valueType extends number ? Number : valueType extends string ? String : valueType extends boolean ? Boolean : ClassType<valueType>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
 export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
     maxLength?: number;
 }

package/src/remult3/Fields.js

@@ -211,6 +211,7 @@ var Relations = /** @class */ (function () {
                 ? {}
                 : options);
         if (!op.field && !op.fields && !op.findOptions)
+            //@ts-ignore
             return Field(toEntityType, tslib_1.__assign(tslib_1.__assign({}, op), (_a = {}, _a[relationInfoMember_js_1.relationInfoMember] = {
                 //field,
                 toType: toEntityType,

package/src/remult3/RepositoryImplementation.js

@@ -234,13 +234,31 @@ var RepositoryImplementation = /** @class */ (function () {
     };
     RepositoryImplementation.prototype.delete = function (item) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var ref, ref2_1, ref2;
             return tslib_1.__generator(this, function (_a) {
-                if (typeof item === 'string' || typeof item === 'number')
-                    return [2 /*return*/, this.edp.delete(item)];
-                else {
-                    return [2 /*return*/, this.getRefForExistingRow(item, undefined).delete()];
+                switch (_a.label) {
+                    case 0:
+                        ref = (0, getEntityRef_js_1.getEntityRef)(item, false);
+                        if (ref)
+                            return [2 /*return*/, ref.delete()];
+                        if (!(typeof item === 'string' || typeof item === 'number')) return [3 /*break*/, 4];
+                        if (!this.dataProvider.isProxy) return [3 /*break*/, 1];
+                        return [2 /*return*/, this.edp.delete(item)];
+                    case 1: return [4 /*yield*/, this.findId(item)];
+                    case 2:
+                        ref2_1 = _a.sent();
+                        if (!ref2_1) return [3 /*break*/, 4];
+                        return [4 /*yield*/, (0, getEntityRef_js_1.getEntityRef)(ref2_1).delete()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        ref2 = this.getRefForExistingRow(item, undefined);
+                        if (!!this.dataProvider.isProxy) return [3 /*break*/, 6];
+                        return [4 /*yield*/, ref2.reload()];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, ref2.delete()];
                 }
-                return [2 /*return*/];
             });
         });
     };

package/src/remult3/remult3.js

@@ -8,11 +8,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //p1 - v - add schema option to create postgres data provider
 /*p1 - V -  with remult async for remultexpress
 //y1 - lint tests (reference to js)
+//p1 - V Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
+//p1 - V Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
 //p1 - V withRemult function Add a with remult to Remult! - there is an existing one called Remult.run
 //p1 - V -  dbname to metadata consider making dbname in the field metadata options - non optional, so it'll be clear that it always have value - something like require the specific key - or move it to the metadata field
 //p1 - V - getEntityRefClone  What I would like is to make a copy of the item (without getting it from the server again)
 //p1 - V find one i had a question about find first's different syntax from find that confused a user
-
+//p1 - https://dexie.org/
 rename V - withremultpromise to that withRemultAsync
 expose live query storage in remult
 
@@ -63,8 +65,6 @@ remult.apiClient.url='localhost:3007/api
 //y2 - discuss a default date formatter
 //y2 - add some api testing framework for user unit tests (will help with codesandbox based discussions)
 //y2 - live query refresh of view on table update
-//y2 - Operator '>' cannot be applied to types 'Number' and 'number'.ts(2365) - change fields to <entityType,number> (now it's Number)
-//y2 - Field(()=>String) - doesn't play nice with strict mode - it prevents people from extending basic types
 //y2 - livequery for findfirst (@JY)
 //y2 - #239 - (@JY) add a way to get from fieldMetadata back to entity repo (like we have in fieldRef)
 //p2 - constraints (@JY)