@minimaltech/node-infra
Version:
Minimal Technology NodeJS Infrastructure - Loopback 4 Framework
107 lines • 5.43 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultHasManyPolymorphicRepository = exports.createHasManyPolymorphicRepositoryFactoryFor = exports.createHasManyPolymorphicInclusionResolver = void 0;
const utilities_1 = require("../../../../utilities");
const repository_1 = require("@loopback/repository");
const get_1 = __importDefault(require("lodash/get"));
const base_repository_1 = require("../../base.repository");
// ----------------------------------------------------------------------------------------------------------------------------------------
/**
* @experimental
*/
const createHasManyPolymorphicInclusionResolver = (opts) => {
const { principalType, relationMetadata, targetRepositoryGetter } = opts;
return (entities, inclusion, options) => __awaiter(void 0, void 0, void 0, function* () {
var _a;
if (!entities.length) {
return [];
}
const sourceKey = relationMetadata.keyFrom;
if (!sourceKey) {
throw (0, utilities_1.getError)({
message: `[createHasManyPolymorphicInclusionResolver] Invalid sourceKey | relationMetadata: ${JSON.stringify(relationMetadata)}`,
});
}
const polymorphicFields = getPolymorphicFields(relationMetadata.polymorphic);
const sourceIds = entities.map(e => (0, get_1.default)(e, sourceKey));
const targetKey = polymorphicFields.idField;
const scope = typeof inclusion === 'string' ? {} : inclusion.scope;
const targetRepository = yield targetRepositoryGetter();
const filter = Object.assign(Object.assign({}, scope), { where: new base_repository_1.WhereBuilder(Object.assign({}, ((_a = scope === null || scope === void 0 ? void 0 : scope.where) !== null && _a !== void 0 ? _a : {})))
.inq(polymorphicFields.idField, sourceIds)
.eq(polymorphicFields.typeField, principalType)
.build() });
const targets = yield targetRepository.find(filter, options);
return (0, repository_1.flattenTargetsOfOneToManyRelation)(sourceIds, targets, targetKey);
});
};
exports.createHasManyPolymorphicInclusionResolver = createHasManyPolymorphicInclusionResolver;
// ----------------------------------------------------------------------------------------------------------------------------------------
/**
* @experimental
*/
const createHasManyPolymorphicRepositoryFactoryFor = (opts) => {
const { principalType, relationMetadata, targetRepositoryGetter } = opts;
const rs = (sourceId) => {
return new DefaultHasManyPolymorphicRepository({
targetRepositoryGetter,
polymorphic: Object.assign(Object.assign({}, relationMetadata.polymorphic), { typeValue: principalType, idValue: sourceId }),
});
};
rs.inclusionResolver = (0, exports.createHasManyPolymorphicInclusionResolver)(opts);
return rs;
};
exports.createHasManyPolymorphicRepositoryFactoryFor = createHasManyPolymorphicRepositoryFactoryFor;
// ----------------------------------------------------------------------------------------------------------------------------------------
const getPolymorphicFields = (opts) => {
const { discriminator } = opts;
let typeField = null;
let idField = null;
switch (typeof discriminator) {
case 'string': {
typeField = `${discriminator}Type`;
idField = `${discriminator}Id`;
break;
}
case 'object': {
typeField = discriminator.typeField;
idField = discriminator.idField;
break;
}
default: {
throw (0, utilities_1.getError)({
statusCode: 500,
message: `[getFields] discriminator: ${typeof discriminator} | Invalid discriminator type!`,
});
}
}
return { typeField, idField };
};
// ----------------------------------------------------------------------------------------------------------------------------------------
/**
* @experimental
*/
class DefaultHasManyPolymorphicRepository extends repository_1.DefaultHasManyRepository {
constructor(opts) {
const { targetRepositoryGetter, polymorphic } = opts;
const { typeField, idField } = getPolymorphicFields(polymorphic);
super(targetRepositoryGetter, {
[typeField]: polymorphic.typeValue,
[idField]: polymorphic.idValue,
});
}
}
exports.DefaultHasManyPolymorphicRepository = DefaultHasManyPolymorphicRepository;
//# sourceMappingURL=factory.js.map