remult 0.27.21-next.13 → 0.27.21-next.14

package/esm/internals.js

@@ -1,4 +1,5 @@
 import { remultStatic } from './src/remult-static.js';
+export { sqlRelations, SqlRelationFilter, } from '../core/src/data-providers/sql-relations.js';
 export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
 export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';

package/esm/src/data-providers/sql-relations.js

@@ -0,0 +1,126 @@
+import { dbNamesOf, repo, SqlDatabase,
+// } from 'remult'
+ } from '../../index.js'; // comment in the from `remult`
+import { getRelationFieldInfo } from '../../internals.js'; // comment in the from `remult`
+// import { getRelationFieldInfo } from 'remult/internals'
+export function sqlRelations(forEntity) {
+    return new Proxy({}, {
+        get: (target, relationField) => new Proxy(new SqlRelationTools(forEntity, relationField), {
+            get: (target, prop) => {
+                if (prop == '$count')
+                    return target.$count;
+                if (prop == '$subQuery')
+                    return target.$subQuery;
+                if (prop == '$relations')
+                    return target.___relations();
+                if (prop == '$first')
+                    return target.$first;
+                return target.$fields[prop];
+            },
+        }),
+    });
+}
+class SqlRelationTools {
+    myEntity;
+    relationField;
+    constructor(myEntity, relationField) {
+        this.myEntity = myEntity;
+        this.relationField = relationField;
+    }
+    $count = (where) => {
+        return this.$subQuery(() => 'count(*)', { where });
+    };
+    $first = (options) => {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                if (prop == '$subQuery')
+                    return (what) => target.$subQuery(what, { ...options, first: true });
+                if (prop == '$relations')
+                    return this.___relations({ ...options, first: true });
+                return target.$subQuery((fieldNamesOfToEntity) => fieldNamesOfToEntity.$dbNameOf(prop), { ...options, first: true });
+            },
+        });
+    };
+    $fields = new Proxy(this, {
+        get: (target, field) => {
+            return target.$subQuery((fieldNamesOfToEntity) => fieldNamesOfToEntity.$dbNameOf(field));
+        },
+    });
+    $subQuery = async (what, options) => {
+        const rel = getRelationFieldInfo(repo(this.myEntity).fields.find(this.relationField));
+        if (!rel)
+            throw new Error(`${this.relationField} is not a relation`);
+        const relFields = rel.getFields();
+        const filters = [];
+        const namesOfOtherTable = await dbNamesOf(rel.toEntity, {
+            tableName: true,
+        });
+        const namesOfMyTable = await dbNamesOf(this.myEntity, { tableName: true });
+        for (const key in relFields.fields) {
+            if (Object.prototype.hasOwnProperty.call(relFields.fields, key)) {
+                filters.push(`${namesOfOtherTable.$dbNameOf(key)} = ${namesOfMyTable.$dbNameOf(relFields.fields[key])}`);
+            }
+        }
+        const otherTableFilter = await SqlDatabase.filterToRaw(repo(rel.toEntity), 
+        // eslint-disable-next-line
+        options?.where, undefined, namesOfOtherTable);
+        if (otherTableFilter)
+            filters.push(otherTableFilter);
+        let result = `
+( SELECT ${await what(namesOfOtherTable)} 
+  FROM ${namesOfOtherTable} 
+  WHERE ${filters.join(' and ')}`;
+        if (options?.orderBy) {
+            result += `
+  ORDER BY ${Object.keys(options.orderBy)
+                .map((key) => `${namesOfOtherTable.$dbNameOf(key)} ${options.orderBy[key]}`)
+                .join(', ')}`;
+        }
+        if (options?.first) {
+            result += `
+  LIMIT 1`;
+        }
+        return (result +
+            `
+)`);
+    };
+    ___relations(options) {
+        return new Proxy(this, {
+            get: (target, field) => {
+                const rel1 = getRelationFieldInfo(repo(this.myEntity).fields.find(this.relationField));
+                return new Proxy(this, {
+                    get: (target, field1) => {
+                        return this.$subQuery(() => indent(sqlRelations(rel1.toEntity)[field][field1]), options);
+                    },
+                });
+            },
+        });
+    }
+}
+export function sqlRelationsFilter(forEntity) {
+    return new Proxy({}, {
+        get: (target, relationField) => new SqlRelationFilter(forEntity, relationField),
+    });
+}
+export class SqlRelationFilter {
+    _tools;
+    constructor(myEntity, relationField) {
+        this._tools = new SqlRelationTools(myEntity, relationField);
+    }
+    some(where) {
+        //many orms use some, every, none
+        return SqlDatabase.rawFilter(async (c) => {
+            return ('exists ' +
+                (await this._tools.$subQuery(() => '1', {
+                    where,
+                    c,
+                })));
+        });
+    }
+}
+function indent(s) {
+    return s.then((s) => s
+        .split('\n')
+        .map((x) => '  ' + x)
+        .join('\n'));
+}

package/internals.d.ts

@@ -1,3 +1,4 @@
+export { sqlRelations, SqlRelationFilter, } from '../core/src/data-providers/sql-relations.js';
 export { getRelationInfo, getRelationFieldInfo, type RelationFieldInfo, type RelationInfo, type RelationFields, } from './src/remult3/relationInfoMember.js';
 export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';

package/internals.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flags = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = void 0;
+exports.flags = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.SqlRelationFilter = exports.sqlRelations = void 0;
 var remult_static_js_1 = require("./src/remult-static.js");
+var sql_relations_js_1 = require("../core/src/data-providers/sql-relations.js");
+Object.defineProperty(exports, "sqlRelations", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelations; } });
+Object.defineProperty(exports, "SqlRelationFilter", { enumerable: true, get: function () { return sql_relations_js_1.SqlRelationFilter; } });
 var relationInfoMember_js_1 = require("./src/remult3/relationInfoMember.js");
 Object.defineProperty(exports, "getRelationInfo", { enumerable: true, get: function () { return relationInfoMember_js_1.getRelationInfo; } });
 Object.defineProperty(exports, "getRelationFieldInfo", { enumerable: true, get: function () { return relationInfoMember_js_1.getRelationFieldInfo; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.27.21-next.13",
+    "version": "0.27.21-next.14",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/data-providers/sql-relations.d.ts

@@ -0,0 +1,37 @@
+import { type ClassType, type EntityDbNames, type EntityFilter, type EntityOrderBy, type ObjectMembersOnly, type SqlCommandWithParameters } from '../../index.js';
+export declare function sqlRelations<entityType>(forEntity: ClassType<entityType>): SqlRelations<entityType>;
+export type SqlRelations<entityType> = {
+    [p in keyof ObjectMembersOnly<entityType>]-?: SqlRelation<ArrayItemType<NonNullable<entityType[p]>>>;
+};
+export type SubQueryWhat<toEntity> = (fieldNamesOfToEntity: EntityDbNames<toEntity>) => string | Promise<string>;
+export type SubQueryOptions<toEntity> = {
+    where?: EntityFilter<toEntity>;
+    orderBy?: EntityOrderBy<toEntity>;
+    first?: boolean;
+    c?: SqlCommandWithParameters;
+};
+export type SqlFirst<toEntity> = {
+    $subQuery(what: SubQueryWhat<toEntity>): Promise<string>;
+    $relations: {
+        [P in keyof ObjectMembersOnly<toEntity>]-?: SqlRelation<toEntity[P]>;
+    };
+} & {
+    [P in keyof toEntity]-?: Promise<string>;
+};
+export type SqlRelation<toEntity> = {
+    $count(where?: EntityFilter<toEntity>): Promise<string>;
+    $subQuery(what: SubQueryWhat<toEntity>, options?: SubQueryOptions<toEntity>): Promise<string>;
+    $relations: {
+        [P in keyof ObjectMembersOnly<toEntity>]-?: SqlRelation<toEntity[P]>;
+    };
+    $first(options?: Pick<SubQueryOptions<toEntity>, 'where' | 'orderBy'>): SqlFirst<toEntity>;
+} & {
+    [P in keyof toEntity]-?: Promise<string>;
+};
+export type ArrayItemType<T> = T extends (infer U)[] ? U : T;
+export declare function sqlRelationsFilter<entityType>(forEntity: ClassType<entityType>): { [p in keyof entityType]-?: SqlRelationFilter<entityType, p, ArrayItemType<NonNullable<entityType[p]>>>; };
+export declare class SqlRelationFilter<myEntity, relationKey extends keyof myEntity, toEntity = ArrayItemType<myEntity[relationKey]>> {
+    private _tools;
+    constructor(myEntity: ClassType<myEntity>, relationField: relationKey);
+    some(where?: EntityFilter<toEntity>): EntityFilter<toEntity>;
+}

package/src/data-providers/sql-relations.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlRelationFilter = void 0;
+exports.sqlRelations = sqlRelations;
+exports.sqlRelationsFilter = sqlRelationsFilter;
+var tslib_1 = require("tslib");
+var index_js_1 = require("../../index.js"); // comment in the from `remult`
+var internals_js_1 = require("../../internals.js"); // comment in the from `remult`
+// import { getRelationFieldInfo } from 'remult/internals'
+function sqlRelations(forEntity) {
+    return new Proxy({}, {
+        get: function (target, relationField) {
+            return new Proxy(new SqlRelationTools(forEntity, relationField), {
+                get: function (target, prop) {
+                    if (prop == '$count')
+                        return target.$count;
+                    if (prop == '$subQuery')
+                        return target.$subQuery;
+                    if (prop == '$relations')
+                        return target.___relations();
+                    if (prop == '$first')
+                        return target.$first;
+                    return target.$fields[prop];
+                },
+            });
+        },
+    });
+}
+var SqlRelationTools = /** @class */ (function () {
+    function SqlRelationTools(myEntity, relationField) {
+        var _this = this;
+        this.myEntity = myEntity;
+        this.relationField = relationField;
+        this.$count = function (where) {
+            return _this.$subQuery(function () { return 'count(*)'; }, { where: where });
+        };
+        this.$first = function (options) {
+            return new Proxy(_this, {
+                get: function (target, prop) {
+                    if (prop == '$subQuery')
+                        return function (what) {
+                            return target.$subQuery(what, tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                        };
+                    if (prop == '$relations')
+                        return _this.___relations(tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                    return target.$subQuery(function (fieldNamesOfToEntity) {
+                        return fieldNamesOfToEntity.$dbNameOf(prop);
+                    }, tslib_1.__assign(tslib_1.__assign({}, options), { first: true }));
+                },
+            });
+        };
+        this.$fields = new Proxy(this, {
+            get: function (target, field) {
+                return target.$subQuery(function (fieldNamesOfToEntity) {
+                    return fieldNamesOfToEntity.$dbNameOf(field);
+                });
+            },
+        });
+        this.$subQuery = function (what, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var rel, relFields, filters, namesOfOtherTable, namesOfMyTable, key, otherTableFilter, result, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        rel = (0, internals_js_1.getRelationFieldInfo)((0, index_js_1.repo)(this.myEntity).fields.find(this.relationField));
+                        if (!rel)
+                            throw new Error("".concat(this.relationField, " is not a relation"));
+                        relFields = rel.getFields();
+                        filters = [];
+                        return [4 /*yield*/, (0, index_js_1.dbNamesOf)(rel.toEntity, {
+                                tableName: true,
+                            })];
+                    case 1:
+                        namesOfOtherTable = _b.sent();
+                        return [4 /*yield*/, (0, index_js_1.dbNamesOf)(this.myEntity, { tableName: true })];
+                    case 2:
+                        namesOfMyTable = _b.sent();
+                        for (key in relFields.fields) {
+                            if (Object.prototype.hasOwnProperty.call(relFields.fields, key)) {
+                                filters.push("".concat(namesOfOtherTable.$dbNameOf(key), " = ").concat(namesOfMyTable.$dbNameOf(relFields.fields[key])));
+                            }
+                        }
+                        return [4 /*yield*/, index_js_1.SqlDatabase.filterToRaw((0, index_js_1.repo)(rel.toEntity), 
+                            // eslint-disable-next-line
+                            options === null || options === void 0 ? void 0 : options.where, undefined, namesOfOtherTable)];
+                    case 3:
+                        otherTableFilter = _b.sent();
+                        if (otherTableFilter)
+                            filters.push(otherTableFilter);
+                        _a = "\n( SELECT ".concat;
+                        return [4 /*yield*/, what(namesOfOtherTable)];
+                    case 4:
+                        result = _a.apply("\n( SELECT ", [_b.sent(), " \n  FROM "]).concat(namesOfOtherTable, " \n  WHERE ").concat(filters.join(' and '));
+                        if (options === null || options === void 0 ? void 0 : options.orderBy) {
+                            result += "\n  ORDER BY ".concat(Object.keys(options.orderBy)
+                                .map(function (key) {
+                                return "".concat(namesOfOtherTable.$dbNameOf(key), " ").concat(options.orderBy[key]);
+                            })
+                                .join(', '));
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.first) {
+                            result += "\n  LIMIT 1";
+                        }
+                        return [2 /*return*/, (result +
+                                "\n)")];
+                }
+            });
+        }); };
+    }
+    SqlRelationTools.prototype.___relations = function (options) {
+        var _this = this;
+        return new Proxy(this, {
+            get: function (target, field) {
+                var rel1 = (0, internals_js_1.getRelationFieldInfo)((0, index_js_1.repo)(_this.myEntity).fields.find(_this.relationField));
+                return new Proxy(_this, {
+                    get: function (target, field1) {
+                        return _this.$subQuery(function () {
+                            return indent(sqlRelations(rel1.toEntity)[field][field1]);
+                        }, options);
+                    },
+                });
+            },
+        });
+    };
+    return SqlRelationTools;
+}());
+function sqlRelationsFilter(forEntity) {
+    return new Proxy({}, {
+        get: function (target, relationField) {
+            return new SqlRelationFilter(forEntity, relationField);
+        },
+    });
+}
+var SqlRelationFilter = /** @class */ (function () {
+    function SqlRelationFilter(myEntity, relationField) {
+        this._tools = new SqlRelationTools(myEntity, relationField);
+    }
+    SqlRelationFilter.prototype.some = function (where) {
+        var _this = this;
+        //many orms use some, every, none
+        return index_js_1.SqlDatabase.rawFilter(function (c) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = 'exists ';
+                        return [4 /*yield*/, this._tools.$subQuery(function () { return '1'; }, {
+                                where: where,
+                                c: c,
+                            })];
+                    case 1: return [2 /*return*/, (_a +
+                            (_b.sent()))];
+                }
+            });
+        }); });
+    };
+    return SqlRelationFilter;
+}());
+exports.SqlRelationFilter = SqlRelationFilter;
+function indent(s) {
+    return s.then(function (s) {
+        return s
+            .split('\n')
+            .map(function (x) { return '  ' + x; })
+            .join('\n');
+    });
+}