podverse-orm 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/src/services/item/item.js

@@ -0,0 +1,113 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemService = void 0;
+const item_1 = require("@/entities/item/item");
+const applyProperties_1 = require("@/lib/applyProperties");
+const typeorm_1 = require("typeorm");
+const db_1 = require("@/db");
+class ItemService {
+    constructor() {
+        this.repository = db_1.AppDataSource.getRepository(item_1.Item);
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({ where: { id }, relations: ['item_chapters_feed'] });
+        });
+    }
+    _getByIdText(id_text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({ where: { id_text } });
+        });
+    }
+    getBy(channel, dto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let item = null;
+            if (dto.guid) {
+                item = yield this.getByGuid(channel, dto.guid);
+            }
+            if (!item && dto.guid_enclosure_url) {
+                item = yield this.getByEnclosureUrl(channel, dto.guid_enclosure_url);
+            }
+            return item;
+        });
+    }
+    getByGuid(channel, guid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({
+                where: {
+                    channel,
+                    guid
+                }
+            });
+        });
+    }
+    getByEnclosureUrl(channel, guid_enclosure_url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.findOne({
+                where: {
+                    channel,
+                    guid_enclosure_url
+                }
+            });
+        });
+    }
+    getAllItemsByChannel(channel, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.find(Object.assign({ where: {
+                    channel,
+                    live_item: {
+                        id: (0, typeorm_1.IsNull)()
+                    }
+                } }, options));
+        });
+    }
+    getAllItemsWithLiveItemByChannel(channel, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.find(Object.assign({ where: {
+                    channel,
+                    live_item: {
+                        id: (0, typeorm_1.Not)((0, typeorm_1.IsNull)())
+                    }
+                } }, options));
+        });
+    }
+    update(channel, dto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let item = yield this.getBy(channel, {
+                guid_enclosure_url: dto.guid_enclosure_url,
+                guid: dto.guid
+            });
+            if (!item) {
+                item = new item_1.Item();
+                item.guid = dto.guid;
+                item.guid_enclosure_url = dto.guid_enclosure_url;
+                item.channel = channel;
+                item = yield this.repository.save(item);
+            }
+            item = (0, applyProperties_1.applyProperties)(item, dto);
+            return this.repository.save(item);
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.repository.delete(id);
+        });
+    }
+    deleteMany(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ids.length) {
+                yield this.repository.delete(ids);
+            }
+        });
+    }
+}
+exports.ItemService = ItemService;

package/dist/src/services/item/itemAbout.d.ts

@@ -0,0 +1,16 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemAbout } from '@/entities/item/itemAbout';
+import { ItemItunesEpisodeTypeEnum } from '@/entities/item/itemItunesEpisodeType';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemAboutDto = {
+    duration: string | null;
+    explicit: boolean | null;
+    website_link_url: string | null;
+    item_itunes_episode_type: ItemItunesEpisodeTypeEnum;
+};
+export declare class ItemAboutService extends BaseOneService<ItemAbout, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemAboutDto): Promise<ItemAbout>;
+}
+export {};

package/dist/src/services/item/itemAbout.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemAboutService = void 0;
+const itemAbout_1 = require("@/entities/item/itemAbout");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemAboutService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemAbout_1.ItemAbout, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto, { relations: ['item_itunes_episode_type'] });
+        });
+    }
+}
+exports.ItemAboutService = ItemAboutService;

package/dist/src/services/item/itemChapter.d.ts

@@ -0,0 +1,16 @@
+import { ItemChapter } from '@/entities/item/itemChapter';
+import { ItemChaptersFeed } from '@/entities/item/itemChaptersFeed';
+import { BaseManyService } from '@/services/base/baseManyService';
+export type ItemChapterDto = {
+    start_time: string;
+    end_time: string | null;
+    title: string | null;
+    web_url: string | null;
+    table_of_contents: boolean;
+};
+export declare class ItemChapterService extends BaseManyService<ItemChapter, 'item_chapters_feed'> {
+    constructor();
+    update(item_chapters_feed: ItemChaptersFeed, dto: ItemChapterDto): Promise<ItemChapter>;
+    updateMany(item_chapters_feed: ItemChaptersFeed, dtos: ItemChapterDto[]): Promise<ItemChapter[]>;
+    deleteMany(ids: number[]): Promise<void>;
+}

package/dist/src/services/item/itemChapter.js

@@ -0,0 +1,45 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemChapterService = void 0;
+const itemChapter_1 = require("@/entities/item/itemChapter");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemChapterService extends baseManyService_1.BaseManyService {
+    constructor() {
+        super(itemChapter_1.ItemChapter, 'item_chapters_feed');
+    }
+    update(item_chapters_feed, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'end_time', 'table_of_contents'];
+            return _super._update.call(this, item_chapters_feed, whereKeys, dto);
+        });
+    }
+    updateMany(item_chapters_feed, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'end_time', 'table_of_contents'];
+            return _super._updateMany.call(this, item_chapters_feed, whereKeys, dtos);
+        });
+    }
+    deleteMany(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ids.length) {
+                yield this.repository.delete(ids);
+            }
+        });
+    }
+}
+exports.ItemChapterService = ItemChapterService;

package/dist/src/services/item/itemChaptersFeed.d.ts

@@ -0,0 +1,13 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemChaptersFeed } from '@/entities/item/itemChaptersFeed';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemChaptersFeedDto = {
+    url: string;
+    type: string;
+};
+export declare class ItemChaptersFeedService extends BaseOneService<ItemChaptersFeed, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemChaptersFeedDto): Promise<ItemChaptersFeed>;
+}
+export {};

package/dist/src/services/item/itemChaptersFeed.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemChaptersFeedService = void 0;
+const itemChaptersFeed_1 = require("@/entities/item/itemChaptersFeed");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemChaptersFeedService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemChaptersFeed_1.ItemChaptersFeed, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemChaptersFeedService = ItemChaptersFeedService;

package/dist/src/services/item/itemChaptersFeedLog.d.ts

@@ -0,0 +1,14 @@
+import { ItemChaptersFeed } from '@/entities/item/itemChaptersFeed';
+import { ItemChaptersFeedLog } from '@/entities/item/itemChaptersFeedLog';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemChaptersFeedLogDto = {
+    last_http_status?: number | null;
+    last_good_http_status_time?: Date | null;
+    last_finished_parse_time?: Date | null;
+    parse_errors?: number;
+};
+export declare class ItemChaptersFeedLogService extends BaseOneService<ItemChaptersFeedLog, 'item_chapters_feed'> {
+    constructor();
+    update(itemChaptersFeed: ItemChaptersFeed, dto: ItemChaptersFeedLogDto): Promise<ItemChaptersFeedLog>;
+}
+export {};

package/dist/src/services/item/itemChaptersFeedLog.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemChaptersFeedLogService = void 0;
+const itemChaptersFeedLog_1 = require("@/entities/item/itemChaptersFeedLog");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemChaptersFeedLogService extends baseOneService_1.BaseOneService {
+    constructor() {
+        super(itemChaptersFeedLog_1.ItemChaptersFeedLog, 'item_chapters_feed');
+    }
+    update(itemChaptersFeed, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, itemChaptersFeed, dto);
+        });
+    }
+}
+exports.ItemChaptersFeedLogService = ItemChaptersFeedLogService;

package/dist/src/services/item/itemChat.d.ts

@@ -0,0 +1,15 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemChat } from '@/entities/item/itemChat';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemChatDto = {
+    server: string;
+    protocol: string | null;
+    account_id: string | null;
+    space: string | null;
+};
+export declare class ItemChatService extends BaseOneService<ItemChat, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemChatDto): Promise<ItemChat>;
+}
+export {};

package/dist/src/services/item/itemChat.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemChatService = void 0;
+const itemChat_1 = require("@/entities/item/itemChat");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemChatService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemChat_1.ItemChat, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemChatService = ItemChatService;

package/dist/src/services/item/itemContentLink.d.ts

@@ -0,0 +1,13 @@
+import { Item } from '@/entities/item/item';
+import { ItemContentLink } from '@/entities/item/itemContentLink';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemContentLinkDto = {
+    url: string;
+    title?: string | null;
+};
+export declare class ItemContentLinkService extends BaseManyService<ItemContentLink, 'item'> {
+    constructor();
+    update(item: Item, dto: ItemContentLinkDto): Promise<ItemContentLink>;
+    updateMany(item: Item, dtos: ItemContentLinkDto[]): Promise<ItemContentLink[]>;
+}
+export {};

package/dist/src/services/item/itemContentLink.js

@@ -0,0 +1,38 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemContentLinkService = void 0;
+const itemContentLink_1 = require("@/entities/item/itemContentLink");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemContentLinkService extends baseManyService_1.BaseManyService {
+    constructor() {
+        super(itemContentLink_1.ItemContentLink, 'item');
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['href'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['href'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemContentLinkService = ItemContentLinkService;

package/dist/src/services/item/itemDescription.d.ts

@@ -0,0 +1,12 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemDescription } from '@/entities/item/itemDescription';
+import { BaseOneService } from '@/services/base/baseOneService';
+type ItemDescriptionDto = {
+    value: string;
+};
+export declare class ItemDescriptionService extends BaseOneService<ItemDescription, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemDescriptionDto): Promise<ItemDescription>;
+}
+export {};

package/dist/src/services/item/itemDescription.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemDescriptionService = void 0;
+const itemDescription_1 = require("@/entities/item/itemDescription");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemDescriptionService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemDescription_1.ItemDescription, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item, dto);
+        });
+    }
+}
+exports.ItemDescriptionService = ItemDescriptionService;

package/dist/src/services/item/itemEnclosure.d.ts

@@ -0,0 +1,21 @@
+import { EntityManager } from 'typeorm';
+import { Item } from '@/entities/item/item';
+import { ItemEnclosure } from '@/entities/item/itemEnclosure';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemEnclosureDto = {
+    type: string;
+    length: number | null;
+    bitrate: number | null;
+    height: number | null;
+    language: string | null;
+    title: string | null;
+    rel: string | null;
+    codecs: string | null;
+    item_enclosure_default: boolean;
+};
+export declare class ItemEnclosureService extends BaseManyService<ItemEnclosure, 'item'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item: Item, dto: ItemEnclosureDto): Promise<ItemEnclosure>;
+    updateMany(item: Item, dtos: ItemEnclosureDto[]): Promise<ItemEnclosure[]>;
+}
+export {};

package/dist/src/services/item/itemEnclosure.js

@@ -0,0 +1,38 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemEnclosureService = void 0;
+const itemEnclosure_1 = require("@/entities/item/itemEnclosure");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemEnclosureService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemEnclosure_1.ItemEnclosure, 'item', transactionalEntityManager);
+    }
+    update(item, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'bitrate'];
+            return _super._update.call(this, item, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'bitrate'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemEnclosureService = ItemEnclosureService;

package/dist/src/services/item/itemEnclosureIntegrity.d.ts

@@ -0,0 +1,13 @@
+import { ItemEnclosure } from '@/entities/item/itemEnclosure';
+import { ItemEnclosureIntegrity } from '@/entities/item/itemEnclosureIntegrity';
+import { BaseOneService } from '@/services/base/baseOneService';
+import { EntityManager } from 'typeorm';
+type ItemEnclosureIntegrityDto = {
+    type: "sri" | "pgp-signature";
+    value: string;
+};
+export declare class ItemEnclosureIntegrityService extends BaseOneService<ItemEnclosureIntegrity, 'item_enclosure'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_enclosure: ItemEnclosure, dto: ItemEnclosureIntegrityDto): Promise<ItemEnclosureIntegrity>;
+}
+export {};

package/dist/src/services/item/itemEnclosureIntegrity.js

@@ -0,0 +1,28 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemEnclosureIntegrityService = void 0;
+const itemEnclosureIntegrity_1 = require("@/entities/item/itemEnclosureIntegrity");
+const baseOneService_1 = require("@/services/base/baseOneService");
+class ItemEnclosureIntegrityService extends baseOneService_1.BaseOneService {
+    constructor(transactionalEntityManager) {
+        super(itemEnclosureIntegrity_1.ItemEnclosureIntegrity, 'item_enclosure', transactionalEntityManager);
+    }
+    update(item_enclosure, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._update.call(this, item_enclosure, dto);
+        });
+    }
+}
+exports.ItemEnclosureIntegrityService = ItemEnclosureIntegrityService;

package/dist/src/services/item/itemEnclosureSource.d.ts

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { ItemEnclosure } from '@/entities/item/itemEnclosure';
+import { ItemEnclosureSource } from '@/entities/item/itemEnclosureSource';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemEnclosureDto = {
+    uri: string;
+    content_type: string | null;
+};
+export declare class ItemEnclosureSourceService extends BaseManyService<ItemEnclosureSource, 'item_enclosure'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_enclosure: ItemEnclosure, dto: ItemEnclosureDto): Promise<ItemEnclosureSource>;
+    updateMany(item_enclosure: ItemEnclosure, dtos: ItemEnclosureDto[]): Promise<ItemEnclosureSource[]>;
+}
+export {};

package/dist/src/services/item/itemEnclosureSource.js

@@ -0,0 +1,38 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemEnclosureSourceService = void 0;
+const itemEnclosureSource_1 = require("@/entities/item/itemEnclosureSource");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemEnclosureSourceService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemEnclosureSource_1.ItemEnclosureSource, 'item_enclosure', transactionalEntityManager);
+    }
+    update(item_enclosure, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._update.call(this, item_enclosure, whereKeys, dto);
+        });
+    }
+    updateMany(item_enclosure, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['uri'];
+            return _super._updateMany.call(this, item_enclosure, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemEnclosureSourceService = ItemEnclosureSourceService;

package/dist/src/services/item/itemFunding.d.ts

@@ -0,0 +1,13 @@
+import { Item } from '@/entities/item/item';
+import { ItemFunding } from '@/entities/item/itemFunding';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemFundingDto = {
+    url: string;
+    title: string | null;
+};
+export declare class ItemFundingService extends BaseManyService<ItemFunding, 'item'> {
+    constructor();
+    update(item: Item, dto: ItemFundingDto): Promise<ItemFunding>;
+    updateMany(item: Item, dtos: ItemFundingDto[]): Promise<ItemFunding[]>;
+}
+export {};