proto.io 0.0.158 → 0.0.160

package/dist/adapters/storage/progres.d.ts

@@ -50,11 +50,9 @@ declare class PostgresDriver extends PostgresClientDriver {
 type Populate = {
     name: string;
     className: string;
+    colname: string;
     type: TSchema.Relation;
-    foreignField?: {
-        colname: string;
-        type: TSchema.Relation;
-    };
+    foreignField?: string;
     subpaths: string[];
     filter: QuerySelector;
     includes: Record<string, TSchema.DataType>;

package/dist/adapters/storage/progres.js

@@ -11,7 +11,7 @@ var Decimal = require('decimal.js');
 var utils = require('pg/lib/utils');
 var index$1 = require('../../internals/index-CSNRyhjB.js');
 require('@o2ter/crypto-js');
-var random$1 = require('../../internals/random-CPI-IjeV.js');
+var random$1 = require('../../internals/random-uT4D0y_q.js');
 var _private = require('../../internals/private-CSB1Ep4g.js');
 
 //
@@ -244,7 +244,7 @@ class QueryCompiler {
         const names = {};
         const populates = {};
         for (const include of includes) {
-            const { paths: [colname, ...subpath], dataType } = random$1._resolveColumn(this.schema, className, include);
+            const { paths: [colname, ...subpath], dataType } = random$1.resolveColumn(this.schema, className, include);
             names[colname] = dataType;
             if (index.isPointer(dataType) || index.isRelation(dataType)) {
                 if (_.isEmpty(subpath))
@@ -261,13 +261,12 @@ class QueryCompiler {
                     colname,
                 };
                 if (index.isRelation(dataType) && dataType.foreignField) {
-                    const targetType = this.schema[dataType.target].fields[dataType.foreignField];
+                    const targetType = random$1.resolveDataType(this.schema, dataType.target, dataType.foreignField);
+                    if (_.isNil(targetType))
+                        throw Error(`Invalid path: ${include}`);
                     if (!index.isPointer(targetType) && !index.isRelation(targetType))
                         throw Error(`Invalid path: ${include}`);
-                    populates[colname].foreignField = {
-                        colname: dataType.foreignField,
-                        type: targetType.type,
-                    };
+                    populates[colname].foreignField = dataType.foreignField;
                 }
                 populates[colname].subpaths.push(subpath.join('.'));
             }
@@ -362,7 +361,7 @@ class QueryCompiler {
     _encodeUpdateAttrs(className, attrs) {
         const updates = [];
         for (const [path, op] of _.toPairs(attrs)) {
-            const { paths: [column, ...subpath], dataType } = random$1._resolveColumn(this.schema, className, path);
+            const { paths: [column, ...subpath], dataType } = random$1.resolveColumn(this.schema, className, path);
             if (index.isShape(dataType)) {
                 const [_op, value] = index.decodeUpdateOp(op);
                 if (_op !== '$set')
@@ -382,7 +381,7 @@ class QueryCompiler {
     _encodeObjectAttrs(className, attrs) {
         const result = {};
         for (const [key, value] of _.toPairs(attrs)) {
-            const { paths: [column, ...subpath], dataType } = random$1._resolveColumn(this.schema, className, key);
+            const { paths: [column, ...subpath], dataType } = random$1.resolveColumn(this.schema, className, key);
             if (!_.isEmpty(subpath))
                 throw Error(`Invalid insert key: ${key}`);
             if (index.isShape(dataType)) {
@@ -788,6 +787,34 @@ class SqlStorage {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
+const foreignFieldType = (schema, className, path) => {
+    let fields = schema[className].fields;
+    let last;
+    let result = false;
+    for (const key of _.toPath(path)) {
+        const dataType = fields[key];
+        if (_.isNil(dataType))
+            return;
+        if (index.isPrimitive(dataType) || index.isVector(dataType))
+            return;
+        if (index.isShape(dataType)) {
+            fields = dataType.shape;
+            continue;
+        }
+        if (_.isNil(schema[dataType.target]))
+            return;
+        if (dataType.type === 'relation')
+            result = true;
+        fields = schema[dataType.target].fields;
+        last = dataType;
+    }
+    if (!last)
+        return;
+    return {
+        target: last.target,
+        type: result ? 'relation' : last.type,
+    };
+};
 const _fetchElement = (parent, colname, subpath, dataType) => {
     const element = sql `${{ identifier: parent.name }}.${{ identifier: parent.name.startsWith('_expr_$') ? '$' : colname }}`;
     if (!parent.className) {
@@ -828,7 +855,7 @@ const _fetchElement = (parent, colname, subpath, dataType) => {
     return { element, json: false };
 };
 const resolvePaths = (compiler, className, paths) => {
-    const { paths: [colname, ...subpath], dataType } = random$1._resolveColumn(compiler.schema, className, paths.join('.'));
+    const { paths: [colname, ...subpath], dataType } = random$1.resolveColumn(compiler.schema, className, paths.join('.'));
     if (!_.isEmpty(subpath) && index.isVector(dataType)) {
         if (subpath.length !== 1)
             throw Error(`Invalid key: ${paths.join('.')}`);
@@ -854,14 +881,38 @@ const resolvePaths = (compiler, className, paths) => {
 const fetchElement = (compiler, parent, field) => {
     if (parent.className) {
         const { dataType, colname, subpath } = resolvePaths(compiler, parent.className, _.toPath(field));
+        const { element, json } = _fetchElement(parent, colname, subpath, dataType);
+        if (!_.isEmpty(subpath)) {
+            const foreignField = foreignFieldType(compiler.schema, parent.className, field);
+            if (foreignField) {
+                return {
+                    element,
+                    dataType: foreignField,
+                    relation: {
+                        target: foreignField.target,
+                        sql: (callback) => sql `SELECT 
+              ${callback(sql `UNNEST`)} 
+            FROM UNNEST(${{ identifier: parent.name }}.${{ identifier: colname }})`,
+                    },
+                };
+            }
+        }
         if (index.isPointer(dataType))
             return { element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}._id` }}`, dataType };
-        const { element, json } = _fetchElement(parent, colname, subpath, dataType);
-        return { element, json, dataType: json ? null : dataType, relation: index.isRelation(dataType) ? dataType : null };
+        return {
+            element,
+            dataType: json ? null : dataType,
+            relation: index.isRelation(dataType) ? {
+                target: dataType.target,
+                sql: (callback) => sql `SELECT
+          ${callback(sql `${json ? sql `VALUE` : sql `UNNEST`}`)}
+        FROM ${json ? sql `jsonb_array_elements(${element})` : sql `UNNEST(${element})`}`,
+            } : null,
+        };
     }
     const [colname, ...subpath] = _.toPath(field);
-    const { element, json } = _fetchElement(parent, colname, subpath);
-    return { element, json, dataType: null, relation: null };
+    const { element } = _fetchElement(parent, colname, subpath);
+    return { element, dataType: null, relation: null };
 };
 
 //
@@ -1807,7 +1858,7 @@ const encodeQueryExpression = (compiler, parent, expr) => {
 //
 const encodeFieldExpression = (compiler, context, parent, field, expr) => {
     const [colname] = _.toPath(field);
-    const { element, json, dataType, relation } = fetchElement(compiler, parent, field);
+    const { element, dataType, relation } = fetchElement(compiler, parent, field);
     const encodeValue = (value) => dataType ? encodeType(colname, dataType, value) : _encodeJsonValue(index._encodeValue(value));
     switch (expr.type) {
         case '$eq':
@@ -1967,10 +2018,10 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (dataType === 'array' || (!_.isString(dataType) && dataType?.type === 'array')) {
                     return sql `${element} <@ ${{ value: index._encodeValue(expr.value) }}`;
                 }
-                else if (!_.isString(dataType) && dataType?.type === 'relation') {
+                else if (relation) {
                     if (!_.every(expr.value, x => x instanceof index.TObject && x.objectId))
                         break;
-                    return sql `ARRAY(SELECT (UNNEST ->> '_id') FROM UNNEST(${element})) <@ ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
+                    return sql `ARRAY(${relation.sql((v) => sql `${v} ->> '_id'`)}) <@ ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
                 }
                 else if (!dataType) {
                     return sql `jsonb_typeof(${element}) ${nullSafeEqual()} 'array' AND ${element} <@ ${_encodeJsonValue(index._encodeValue(expr.value))}`;
@@ -1985,10 +2036,10 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (dataType === 'array' || (!_.isString(dataType) && dataType?.type === 'array')) {
                     return sql `${element} @> ${{ value: index._encodeValue(expr.value) }}`;
                 }
-                else if (!_.isString(dataType) && dataType?.type === 'relation') {
+                else if (relation) {
                     if (!_.every(expr.value, x => x instanceof index.TObject && x.objectId))
                         break;
-                    return sql `ARRAY(SELECT (UNNEST ->> '_id') FROM UNNEST(${element})) @> ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
+                    return sql `ARRAY(${relation.sql((v) => sql `${v} ->> '_id'`)}) @> ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
                 }
                 else if (!dataType) {
                     return sql `jsonb_typeof(${element}) ${nullSafeEqual()} 'array' AND ${element} @> ${_encodeJsonValue(index._encodeValue(expr.value))}`;
@@ -2003,10 +2054,10 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (dataType === 'array' || (!_.isString(dataType) && dataType?.type === 'array')) {
                     return sql `NOT ${element} && ${{ value: index._encodeValue(expr.value) }}`;
                 }
-                else if (!_.isString(dataType) && dataType?.type === 'relation') {
+                else if (relation) {
                     if (!_.every(expr.value, x => x instanceof index.TObject && x.objectId))
                         break;
-                    return sql `NOT ARRAY(SELECT (UNNEST ->> '_id') FROM UNNEST(${element})) && ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
+                    return sql `NOT ARRAY(${relation.sql((v) => sql `${v} ->> '_id'`)}) && ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
                 }
                 else if (!dataType) {
                     return sql `jsonb_typeof(${element}) ${nullSafeEqual()} 'array' AND NOT ${element} && ${_encodeJsonValue(index._encodeValue(expr.value))}`;
@@ -2021,10 +2072,10 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                 if (dataType === 'array' || (!_.isString(dataType) && dataType?.type === 'array')) {
                     return sql `${element} && ${{ value: index._encodeValue(expr.value) }}`;
                 }
-                else if (!_.isString(dataType) && dataType?.type === 'relation') {
+                else if (relation) {
                     if (!_.every(expr.value, x => x instanceof index.TObject && x.objectId))
                         break;
-                    return sql `ARRAY(SELECT (UNNEST ->> '_id') FROM UNNEST(${element})) && ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
+                    return sql `ARRAY(${relation.sql((v) => sql `${v} ->> '_id'`)}) && ARRAY[${_.map(expr.value, (x) => sql `${{ value: x.objectId }}`)}]`;
                 }
                 else if (!dataType) {
                     return sql `jsonb_typeof(${element}) ${nullSafeEqual()} 'array' AND ${element} && ${_encodeJsonValue(index._encodeValue(expr.value))}`;
@@ -2131,11 +2182,7 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                     break;
                 if (relation) {
                     return sql `NOT EXISTS(
-            SELECT * FROM (
-              SELECT
-                ${json ? sql `VALUE` : sql `UNNEST`} AS "$"
-              FROM ${json ? sql `jsonb_array_elements(${element})` : sql `UNNEST(${element})`}
-            ) AS ${{ identifier: tempName }}
+            SELECT * FROM (${relation.sql((v) => sql `${v} AS "$"`)}) AS ${{ identifier: tempName }}
             WHERE NOT (${filter})
           )`;
                 }
@@ -2162,11 +2209,7 @@ const encodeFieldExpression = (compiler, context, parent, field, expr) => {
                     break;
                 if (relation) {
                     return sql `EXISTS(
-            SELECT * FROM (
-              SELECT
-                ${json ? sql `VALUE` : sql `UNNEST`} AS "$"
-              FROM ${json ? sql `jsonb_array_elements(${element})` : sql `UNNEST(${element})`}
-            ) AS ${{ identifier: tempName }}
+            SELECT * FROM (${relation.sql((v) => sql `${v} AS "$"`)}) AS ${{ identifier: tempName }}
             WHERE ${filter}
           )`;
                 }
@@ -2229,6 +2272,28 @@ const resolveSubpaths = (compiler, populate) => {
     }
     return subpaths;
 };
+const _isPointer = (schema, className, path) => {
+    let fields = schema[className].fields;
+    let last;
+    for (const key of _.toPath(path)) {
+        const dataType = fields[key];
+        if (_.isNil(dataType))
+            throw Error(`Invalid path: ${path}`);
+        if (index.isPrimitive(dataType) || index.isVector(dataType))
+            throw Error(`Invalid path: ${path}`);
+        if (index.isShape(dataType)) {
+            fields = dataType.shape;
+            continue;
+        }
+        if (dataType.type !== 'pointer')
+            return false;
+        if (_.isNil(schema[dataType.target]))
+            throw Error(`Invalid path: ${path}`);
+        fields = schema[dataType.target].fields;
+        last = dataType;
+    }
+    return last?.type === 'pointer';
+};
 const selectPopulate = (compiler, parent, populate, field) => {
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: populate.name }}.${{ identifier: field }}`;
@@ -2246,11 +2311,11 @@ const selectPopulate = (compiler, parent, populate, field) => {
     if (_.isNil(populate.foreignField)) {
         cond = sql `${sql `(${{ quote: populate.className + '$' }} || ${_foreign('_id')})`} = ANY(${_local(field)})`;
     }
-    else if (populate.foreignField.type === 'pointer') {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(populate.foreignField.colname)}`;
+    else if (_isPointer(compiler.schema, populate.className, populate.foreignField)) {
+        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(populate.colname)}`;
     }
     else {
-        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.foreignField.colname)})`;
+        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.colname)})`;
     }
     return {
         columns: [sql `
@@ -2267,11 +2332,81 @@ const selectPopulate = (compiler, parent, populate, field) => {
     `],
     };
 };
+const encodeRemix = (parent, remix) => sql `${remix?.className === parent.className ? sql `
+  (SELECT * FROM ${{ identifier: remix.name }} UNION SELECT * FROM ${{ identifier: parent.className }})
+` : { identifier: parent.className }}`;
+const encodeForeignField = (compiler, context, parent, foreignField, remix) => {
+    const { paths: [colname, ...subpath], dataType } = random$1.resolveColumn(compiler.schema, parent.className, foreignField);
+    const tempName = `_populate_$${compiler.nextIdx()}`;
+    const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
+    const _foreign = (field) => sql `${{ identifier: tempName }}.${{ identifier: field }}`;
+    if (_.isEmpty(subpath) && index.isRelation(dataType) && dataType.foreignField) {
+        const { joins, field, rows, array } = encodeForeignField(compiler, context, { className: dataType.target, name: tempName }, dataType.foreignField, remix);
+        return {
+            joins: [],
+            field: sql `(
+        SELECT ${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`}
+        FROM ${encodeRemix({ className: dataType.target }, remix)} AS ${{ identifier: tempName }}
+        ${!_.isEmpty(joins) ? { literal: joins, separator: '\n' } : sql ``}
+        WHERE ${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${array || rows ? sql `ANY(${field})` : field}
+      )`,
+            array: false,
+            rows: true,
+        };
+    }
+    if (_.isEmpty(subpath)) {
+        return {
+            joins: [],
+            field: sql `${{ identifier: parent.name }}.${{ identifier: foreignField }}`,
+            array: index.isRelation(dataType),
+            rows: false,
+        };
+    }
+    if (!index.isPointer(dataType) && !index.isRelation(dataType))
+        throw Error(`Invalid path: ${foreignField}`);
+    const { joins, field, rows, array } = encodeForeignField(compiler, context, { className: dataType.target, name: tempName }, subpath.join('.'), remix);
+    if (index.isPointer(dataType)) {
+        return {
+            joins: [sql `
+        LEFT JOIN ${encodeRemix({ className: dataType.target }, remix)} AS ${{ identifier: tempName }}
+        ON ${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ${_local(colname)}
+      `, ...joins],
+            field,
+            array,
+            rows,
+        };
+    }
+    let cond;
+    if (_.isNil(dataType.foreignField)) {
+        cond = sql `${sql `(${{ quote: dataType.target + '$' }} || ${_foreign('_id')})`} = ANY(${_local(colname)})`;
+    }
+    else if (_isPointer(compiler.schema, dataType.target, dataType.foreignField)) {
+        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ${_foreign(dataType.foreignField)}`;
+    }
+    else {
+        cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(dataType.foreignField)})`;
+    }
+    return {
+        joins: [],
+        field: sql `(
+      SELECT ${array ? sql `UNNEST(${field})` : field}
+      FROM ${encodeRemix({ className: dataType.target }, remix)} AS ${{ identifier: tempName }}
+      ${!_.isEmpty(joins) ? { literal: joins, separator: '\n' } : sql ``}
+      WHERE ${cond}
+    )`,
+        array: false,
+        rows: true,
+    };
+};
 const encodePopulate = (compiler, context, parent, remix) => {
     const _filter = compiler._encodeFilter(context, parent, parent.filter);
     const _populates = _.map(parent.populates, (populate, field) => selectPopulate(compiler, parent, populate, field));
     const _joins = _.compact(_.map(_populates, ({ join }) => join));
     const _includes = _.pickBy(parent.includes, v => index.isPrimitive(v));
+    const { joins: _joins2 = [], field: _foreignField = undefined, rows = false, } = parent.foreignField ? encodeForeignField(compiler, context, {
+        className: parent.className,
+        name: parent.name,
+    }, parent.foreignField, remix) : {};
     return _.reduce(parent.populates, (acc, populate) => ({
         ...encodePopulate(compiler, context, populate, remix),
         ...acc,
@@ -2282,14 +2417,12 @@ const encodePopulate = (compiler, context, parent, remix) => {
         ${{
             literal: [
                 ..._.map(_.keys(_includes), colname => sql `${{ identifier: parent.name }}.${{ identifier: colname }}`),
-                ...parent.foreignField ? [sql `${{ identifier: parent.name }}.${{ identifier: parent.foreignField.colname }}`] : [],
                 ..._.flatMap(_populates, ({ columns: column }) => column),
+                ..._foreignField ? [sql `${rows ? sql `ARRAY(${_foreignField})` : _foreignField} AS ${{ identifier: parent.colname }}`] : [],
             ], separator: ',\n'
         }}
-        FROM ${remix?.className === parent.className ? sql `
-        (SELECT * FROM ${{ identifier: remix.name }} UNION SELECT * FROM ${{ identifier: parent.className }})
-        ` : { identifier: parent.className }} AS ${{ identifier: parent.name }}
-        ${!_.isEmpty(_joins) ? { literal: _joins, separator: '\n' } : sql ``}
+        FROM ${encodeRemix(parent, remix)} AS ${{ identifier: parent.name }}
+        ${!_.isEmpty(_joins) || !_.isEmpty(_joins2) ? { literal: [..._joins, ..._joins2], separator: '\n' } : sql ``}
       ) AS ${{ identifier: parent.name }}
       ${_filter ? sql `WHERE ${_filter}` : sql ``}
     `,
@@ -2324,13 +2457,13 @@ const encodeRelation = (compiler, context, parent, relatedBy) => {
     const name = `_relation_$${relatedBy.className.toLowerCase()}`;
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: name }}.${{ identifier: field }}`;
-    return sql `
-  EXISTS (
+    const { joins, field } = encodeForeignField(compiler, context, { className: relatedBy.className, name }, relatedBy.key);
+    return sql `EXISTS (
     SELECT 1
     FROM ${{ identifier: relatedBy.className }} AS ${{ identifier: name }}
-    WHERE ${_foreign('_id')} = ${{ value: relatedBy.objectId }} AND ${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(relatedBy.key)})
-  )
-  `;
+    ${!_.isEmpty(joins) ? { literal: joins, separator: '\n' } : sql ``}
+    WHERE ${_foreign('_id')} = ${{ value: relatedBy.objectId }} AND ${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${field})
+  )`;
 };
 
 //