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

package/dist/src/services/item/itemValueRecipient.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.ItemValueRecipientService = void 0;
+const itemValueRecipient_1 = require("@/entities/item/itemValueRecipient");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemValueRecipientService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemValueRecipient_1.ItemValueRecipient, 'item_value', transactionalEntityManager);
+    }
+    update(item_value, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._update.call(this, item_value, whereKeys, dto);
+        });
+    }
+    updateMany(item_value, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._updateMany.call(this, item_value, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemValueRecipientService = ItemValueRecipientService;

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

@@ -0,0 +1,16 @@
+import { EntityManager } from 'typeorm';
+import { ItemValue } from '@/entities/item/itemValue';
+import { ItemValueTimeSplit } from '@/entities/item/itemValueTimeSplit';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemValueTimeSplitDto = {
+    start_time: string;
+    duration: string;
+    remote_start_time: string;
+    remote_percentage: string;
+};
+export declare class ItemValueTimeSplitService extends BaseManyService<ItemValueTimeSplit, 'item_value'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_value: ItemValue, dto: ItemValueTimeSplitDto): Promise<ItemValueTimeSplit>;
+    updateMany(item: ItemValue, dtos: ItemValueTimeSplitDto[]): Promise<ItemValueTimeSplit[]>;
+}
+export {};

package/dist/src/services/item/itemValueTimeSplit.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.ItemValueTimeSplitService = void 0;
+const itemValueTimeSplit_1 = require("@/entities/item/itemValueTimeSplit");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemValueTimeSplitService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemValueTimeSplit_1.ItemValueTimeSplit, 'item_value', transactionalEntityManager);
+    }
+    update(item_value, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'duration'];
+            return _super._update.call(this, item_value, whereKeys, dto);
+        });
+    }
+    updateMany(item, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['start_time', 'duration'];
+            return _super._updateMany.call(this, item, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemValueTimeSplitService = ItemValueTimeSplitService;

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

@@ -0,0 +1,19 @@
+import { EntityManager } from 'typeorm';
+import { ItemValueTimeSplit } from '@/entities/item/itemValueTimeSplit';
+import { ItemValueTimeSplitRecipient } from '@/entities/item/itemValueTimeSplitRecipient';
+import { BaseManyService } from '@/services/base/baseManyService';
+type ItemValueTimeSplitRecipientDto = {
+    type: string;
+    address: string;
+    split: number;
+    name: string | null;
+    custom_key: string | null;
+    custom_value: string | null;
+    fee: boolean;
+};
+export declare class ItemValueTimeSplitRecipientService extends BaseManyService<ItemValueTimeSplitRecipient, 'item_value_time_split'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_value_time_split: ItemValueTimeSplit, dto: ItemValueTimeSplitRecipientDto): Promise<ItemValueTimeSplitRecipient>;
+    updateMany(item_value_time_split: ItemValueTimeSplit, dtos: ItemValueTimeSplitRecipientDto[]): Promise<ItemValueTimeSplitRecipient[]>;
+}
+export {};

package/dist/src/services/item/itemValueTimeSplitRecipient.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.ItemValueTimeSplitRecipientService = void 0;
+const itemValueTimeSplitRecipient_1 = require("@/entities/item/itemValueTimeSplitRecipient");
+const baseManyService_1 = require("@/services/base/baseManyService");
+class ItemValueTimeSplitRecipientService extends baseManyService_1.BaseManyService {
+    constructor(transactionalEntityManager) {
+        super(itemValueTimeSplitRecipient_1.ItemValueTimeSplitRecipient, 'item_value_time_split', transactionalEntityManager);
+    }
+    update(item_value_time_split, dto) {
+        const _super = Object.create(null, {
+            _update: { get: () => super._update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._update.call(this, item_value_time_split, whereKeys, dto);
+        });
+    }
+    updateMany(item_value_time_split, dtos) {
+        const _super = Object.create(null, {
+            _updateMany: { get: () => super._updateMany }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const whereKeys = ['type', 'address', 'custom_key', 'custom_value'];
+            return _super._updateMany.call(this, item_value_time_split, whereKeys, dtos);
+        });
+    }
+}
+exports.ItemValueTimeSplitRecipientService = ItemValueTimeSplitRecipientService;

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

@@ -0,0 +1,14 @@
+import { EntityManager } from 'typeorm';
+import { ItemValueTimeSplit } from '@/entities/item/itemValueTimeSplit';
+import { ItemValueTimeSplitRemoteItem } from '@/entities/item/itemValueTimeSplitRemoteItem';
+import { BaseRemoteItemsService } from '@/services/base/baseRemoteItemsService';
+type ItemValueTimeSplitRemoteItemDto = {
+    feed_guid: string;
+    feed_url: string | null;
+    item_guid: string | null;
+};
+export declare class ItemValueTimeSplitRemoteItemService extends BaseRemoteItemsService<ItemValueTimeSplitRemoteItem, 'item_value_time_split'> {
+    constructor(transactionalEntityManager?: EntityManager);
+    update(item_value_time_split: ItemValueTimeSplit, dto: ItemValueTimeSplitRemoteItemDto): Promise<ItemValueTimeSplitRemoteItem>;
+}
+export {};

package/dist/src/services/item/itemValueTimeSplitRemoteItem.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.ItemValueTimeSplitRemoteItemService = void 0;
+const itemValueTimeSplitRemoteItem_1 = require("@/entities/item/itemValueTimeSplitRemoteItem");
+const baseRemoteItemsService_1 = require("@/services/base/baseRemoteItemsService");
+class ItemValueTimeSplitRemoteItemService extends baseRemoteItemsService_1.BaseRemoteItemsService {
+    constructor(transactionalEntityManager) {
+        super(itemValueTimeSplitRemoteItem_1.ItemValueTimeSplitRemoteItem, 'item_value_time_split', transactionalEntityManager);
+    }
+    update(item_value_time_split, dto) {
+        const _super = Object.create(null, {
+            update: { get: () => super.update }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.update.call(this, item_value_time_split, dto);
+        });
+    }
+}
+exports.ItemValueTimeSplitRemoteItemService = ItemValueTimeSplitRemoteItemService;

package/dist/src/services/liveItem/liveItem.d.ts

@@ -0,0 +1,14 @@
+import { Item } from '@/entities/item/item';
+import { LiveItem } from '@/entities/liveItem/liveItem';
+import { LiveItemStatusEnum } from '@/entities/liveItem/liveItemStatus';
+import { BaseOneService } from '../base/baseOneService';
+type LiveItemDto = {
+    live_item_status: LiveItemStatusEnum;
+    start_time: Date;
+    end_time: Date | null;
+};
+export declare class LiveItemService extends BaseOneService<LiveItem, 'item'> {
+    constructor();
+    update(item: Item, dto: LiveItemDto): Promise<LiveItem>;
+}
+export {};

package/dist/src/services/liveItem/liveItem.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.LiveItemService = void 0;
+const liveItem_1 = require("@/entities/liveItem/liveItem");
+const baseOneService_1 = require("../base/baseOneService");
+class LiveItemService extends baseOneService_1.BaseOneService {
+    constructor() {
+        super(liveItem_1.LiveItem, 'item');
+    }
+    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: ['live_item_status'] });
+        });
+    }
+}
+exports.LiveItemService = LiveItemService;

package/dist/src/services/medium.d.ts

@@ -0,0 +1,5 @@
+import { Medium } from '@/entities/medium';
+export declare class MediumService {
+    private mediumRepository;
+    mediumGetAll(): Promise<Medium[]>;
+}

package/dist/src/services/medium.js

@@ -0,0 +1,25 @@
+"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.MediumService = void 0;
+const db_1 = require("@/db");
+const medium_1 = require("@/entities/medium");
+class MediumService {
+    constructor() {
+        this.mediumRepository = db_1.AppDataSource.getRepository(medium_1.Medium);
+    }
+    mediumGetAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.mediumRepository.find();
+        });
+    }
+}
+exports.MediumService = MediumService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "podverse-orm",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,9 @@
     "prepare": "npm run build",
     "start": "ts-node ./dist/index.js"
   },
+  "files": [
+    "dist/**/*"
+  ],
   "author": "",
   "license": "AGPLv3",
   "dependencies": {

package/.nvmrc

@@ -1 +0,0 @@
-v20.16.0

package/eslint.config.mjs

@@ -1,44 +0,0 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-import tseslint from "@typescript-eslint/eslint-plugin";
-import tsParser from "@typescript-eslint/parser";
-
-const pluginJsRecommended = {
-  rules: {
-    ...pluginJs.configs.recommended.rules,
-  },
-};
-
-const tseslintRecommended = {
-  rules: {
-    ...tseslint.configs.recommended.rules,
-  },
-};
-
-export default [
-  {
-    files: ["src/**/*.{js,ts}"],
-    languageOptions: {
-      globals: globals.node,
-      parser: tsParser,
-    },
-    plugins: {
-      "@typescript-eslint": tseslint,
-    },
-    rules: {
-      ...pluginJsRecommended.rules,
-      ...tseslintRecommended.rules,
-      "semi": ["error", "always"],
-      "indent": ["error", 2],
-      "@typescript-eslint/no-require-imports": "off",
-    },
-    ignores: ["**/eslint.config.mjs"],
-  },
-  {
-    files: ["src/entities/**/*.{js,ts}"],
-    rules: {
-      "indent": "off",
-    },
-  }
-];
-

package/src/config/index.ts

@@ -1,12 +0,0 @@
-export const config = {
-  nodeEnv: process.env.NODE_ENV || 'development',
-  database: {
-    type: process.env.DB_TYPE || 'postgres',
-    host: process.env.DB_HOST || 'localhost',
-    port: parseInt(process.env.DB_PORT || '5432', 10),
-    username: process.env.DB_USERNAME || 'user',
-    password: process.env.DB_PASSWORD || '',
-    database: process.env.DB_DATABASE || 'db',
-    ssl_connection: process.env.DB_SSL_CONNECTION === 'true',
-  }
-};

package/src/db/index.ts

@@ -1,207 +0,0 @@
-import { DataSource } from "typeorm";
-import { config } from "@orm/config";
-import { Account } from "@orm/entities/account/account";
-import { AccountAdminRoles } from "@orm/entities/account/accountAdminRoles";
-import { AccountAppStorePurchase } from "@orm/entities/account/accountAppStorePurchase";
-import { AccountCredentials } from "@orm/entities/account/accountCredentials";
-import { AccountFCMDevice } from "@orm/entities/account/accountFCMDevice";
-import { AccountFollowingAccount } from "@orm/entities/account/accountFollowingAccount";
-import { AccountFollowingAddByRssChannel } from "@orm/entities/account/accountFollowingAddByRSSChannel";
-import { AccountFollowingChannel } from "@orm/entities/account/accountFollowingChannel";
-import { AccountFollowingPlaylist } from "@orm/entities/account/accountFollowingPlaylist";
-import { AccountGooglePlayPurchase } from "@orm/entities/account/accountGooglePlayPurchase";
-import { AccountMembership } from "@orm/entities/account/accountMembership";
-import { AccountMembershipStatus } from "@orm/entities/account/accountMembershipStatus";
-import { AccountNotification } from "@orm/entities/account/accountNotification";
-import { AccountPaypalOrder } from "@orm/entities/account/accountPayPalOrder";
-import { AccountProfile } from "@orm/entities/account/accountProfile";
-import { AccountResetPassword } from "@orm/entities/account/accountResetPassword";
-import { AccountUpDevice } from "@orm/entities/account/accountUPDevice";
-import { AccountVerification } from "@orm/entities/account/accountVerification";
-import { Category } from "@orm/entities/category";
-import { Feed } from "@orm/entities/feed/feed";
-import { FeedFlagStatus } from "@orm/entities/feed/feedFlagStatus";
-import { FeedLog } from "@orm/entities/feed/feedLog";
-import { Medium } from "@orm/entities/medium";
-import { Channel } from "@orm/entities/channel/channel";
-import { ChannelAbout } from "@orm/entities/channel/channelAbout";
-import { ChannelCategory } from "@orm/entities/channel/channelCategory";
-import { ChannelChat } from "@orm/entities/channel/channelChat";
-import { ChannelDescription } from "@orm/entities/channel/channelDescription";
-import { ChannelFunding } from "@orm/entities/channel/channelFunding";
-import { ChannelImage } from "@orm/entities/channel/channelImage";
-import { ChannelInternalSettings } from "@orm/entities/channel/channelInternalSettings";
-import { ChannelItunesType } from "@orm/entities/channel/channelItunesType";
-import { ChannelLicense } from "@orm/entities/channel/channelLicense";
-import { ChannelLocation } from "@orm/entities/channel/channelLocation";
-import { ChannelPerson } from "@orm/entities/channel/channelPerson";
-import { ChannelPodroll } from "@orm/entities/channel/channelPodroll";
-import { ChannelPodrollRemoteItem } from "@orm/entities/channel/channelPodrollRemoteItem";
-import { ChannelPublisher } from "@orm/entities/channel/channelPublisher";
-import { ChannelPublisherRemoteItem } from "@orm/entities/channel/channelPublisherRemoteItem";
-import { ChannelRemoteItem } from "@orm/entities/channel/channelRemoteItem";
-import { ChannelSeason } from "@orm/entities/channel/channelSeason";
-import { ChannelSocialInteract } from "@orm/entities/channel/channelSocialInteract";
-import { ChannelTrailer } from "@orm/entities/channel/channelTrailer";
-import { ChannelTxt } from "@orm/entities/channel/channelTxt";
-import { ChannelValue } from "@orm/entities/channel/channelValue";
-import { ChannelValueRecipient } from "@orm/entities/channel/channelValueRecipient";
-import { Item } from "@orm/entities/item/item";
-import { ItemAbout } from "@orm/entities/item/itemAbout";
-import { ItemChapter } from "@orm/entities/item/itemChapter";
-import { ItemChapterLocation } from "@orm/entities/item/itemChapterLocation";
-import { ItemChaptersFeed } from "@orm/entities/item/itemChaptersFeed";
-import { ItemChaptersFeedLog } from "@orm/entities/item/itemChaptersFeedLog";
-import { ItemChat } from "@orm/entities/item/itemChat";
-import { ItemContentLink } from "@orm/entities/item/itemContentLink";
-import { ItemDescription } from "@orm/entities/item/itemDescription";
-import { ItemEnclosure } from "@orm/entities/item/itemEnclosure";
-import { ItemEnclosureIntegrity } from "@orm/entities/item/itemEnclosureIntegrity";
-import { ItemEnclosureSource } from "@orm/entities/item/itemEnclosureSource";
-import { ItemFunding } from "@orm/entities/item/itemFunding";
-import { ItemImage } from "@orm/entities/item/itemImage";
-import { ItemItunesEpisodeType } from "@orm/entities/item/itemItunesEpisodeType";
-import { ItemLicense } from "@orm/entities/item/itemLicense";
-import { ItemLocation } from "@orm/entities/item/itemLocation";
-import { ItemPerson } from "@orm/entities/item/itemPerson";
-import { ItemSeason } from "@orm/entities/item/itemSeason";
-import { ItemSeasonEpisode } from "@orm/entities/item/itemSeasonEpisode";
-import { ItemSocialInteract } from "@orm/entities/item/itemSocialInteract";
-import { ItemSoundbite } from "@orm/entities/item/itemSoundbite";
-import { ItemTranscript } from "@orm/entities/item/itemTranscript";
-import { ItemTxt } from "@orm/entities/item/itemTxt";
-import { ItemValue } from "@orm/entities/item/itemValue";
-import { ItemValueRecipient } from "@orm/entities/item/itemValueRecipient";
-import { ItemValueTimeSplit } from "@orm/entities/item/itemValueTimeSplit";
-import { ItemValueTimeSplitRecipient } from "@orm/entities/item/itemValueTimeSplitRecipient";
-import { ItemValueTimeSplitRemoteItem } from "@orm/entities/item/itemValueTimeSplitRemoteItem";
-import { LiveItem } from "@orm/entities/liveItem/liveItem";
-import { LiveItemStatus } from "@orm/entities/liveItem/liveItemStatus";
-import { Playlist } from "@orm/entities/playlist/playlist";
-import { PlaylistResourceBase } from "@orm/entities/playlist/playlistResourceBase";
-import { PlaylistResourceClip } from "@orm/entities/playlist/playlistResourceClip";
-import { PlaylistResourceItem } from "@orm/entities/playlist/playlistResourceItem";
-import { PlaylistResourceItemAddByRss } from "@orm/entities/playlist/playlistResourceItemAddByRSS";
-import { PlaylistResourceItemChapter } from "@orm/entities/playlist/playlistResourceItemChapter";
-import { PlaylistResourceItemSoundbite } from "@orm/entities/playlist/playlistResourceItemSoundbite";
-import { Queue } from "@orm/entities/queue/queue";
-import { QueueResourceBase } from "@orm/entities/queue/queueResourceBase";
-import { QueueResourceClip } from "@orm/entities/queue/queueResourceClip";
-import { QueueResourceItem } from "@orm/entities/queue/queueResourceItem";
-import { QueueResourceItemAddByRss } from "@orm/entities/queue/queueResourceItemAddByRSS";
-import { QueueResourceItemChapter } from "@orm/entities/queue/queueResourceItemChapter";
-import { QueueResourceItemSoundbite } from "@orm/entities/queue/queueResourceItemSoundbite";
-import { Clip } from "@orm/entities/clip";
-import { MembershipClaimToken } from "@orm/entities/membershipClaimToken";
-import { SharableStatus } from "@orm/entities/sharableStatus";
-import { SnakeNamingStrategy } from "typeorm-naming-strategies";
-
-export const AppDataSource = new DataSource({
-  type: "postgres",
-  host: config.database.host,
-  port: config.database.port,
-  username: config.database.username,
-  password: config.database.password,
-  database: config.database.database,
-  synchronize: false,
-  logging: false,
-  entities: [
-    Account,
-    AccountAdminRoles,
-    AccountAppStorePurchase,
-    AccountCredentials,
-    AccountFCMDevice,
-    AccountFollowingAccount,
-    AccountFollowingAddByRssChannel,
-    AccountFollowingChannel,
-    AccountFollowingPlaylist,
-    AccountGooglePlayPurchase,
-    AccountMembership,
-    AccountMembershipStatus,
-    AccountNotification,
-    AccountPaypalOrder,
-    AccountProfile,
-    AccountResetPassword,
-    AccountUpDevice,
-    AccountVerification,
-    Category,
-    Channel,
-    ChannelAbout,
-    ChannelCategory,
-    ChannelChat,
-    ChannelDescription,
-    ChannelFunding,
-    ChannelImage,
-    ChannelInternalSettings,
-    ChannelItunesType,
-    ChannelLicense,
-    ChannelLocation,
-    ChannelPerson,
-    ChannelPodroll,
-    ChannelPodrollRemoteItem,
-    ChannelPublisher,
-    ChannelPublisherRemoteItem,
-    ChannelRemoteItem,
-    ChannelSeason,
-    ChannelSocialInteract,
-    ChannelTrailer,
-    ChannelTxt,
-    ChannelValue,
-    ChannelValueRecipient,
-    Clip,
-    Feed,
-    FeedFlagStatus,
-    FeedLog,
-    Item,
-    ItemAbout,
-    ItemChapter,
-    ItemChapterLocation,
-    ItemChaptersFeed,
-    ItemChaptersFeedLog,
-    ItemChat,
-    ItemContentLink,
-    ItemDescription,
-    ItemEnclosure,
-    ItemEnclosureIntegrity,
-    ItemEnclosureSource,
-    ItemFunding,
-    ItemImage,
-    ItemItunesEpisodeType,
-    ItemLicense,
-    ItemLocation,
-    ItemPerson,
-    ItemSeason,
-    ItemSeasonEpisode,
-    ItemSocialInteract,
-    ItemSoundbite,
-    ItemTranscript,
-    ItemTxt,
-    ItemValue,
-    ItemValueRecipient,
-    ItemValueTimeSplit,
-    ItemValueTimeSplitRecipient,
-    ItemValueTimeSplitRemoteItem,
-    LiveItem,
-    LiveItemStatus,
-    MembershipClaimToken,
-    Medium,
-    Playlist,
-    PlaylistResourceBase,
-    PlaylistResourceClip,
-    PlaylistResourceItem,
-    PlaylistResourceItemAddByRss,
-    PlaylistResourceItemChapter,
-    PlaylistResourceItemSoundbite,
-    Queue,
-    QueueResourceBase,
-    QueueResourceClip,
-    QueueResourceItem,
-    QueueResourceItemAddByRss,
-    QueueResourceItemChapter,
-    QueueResourceItemSoundbite,
-    SharableStatus
-  ],
-  migrations: [],
-  subscribers: [],
-  namingStrategy: new SnakeNamingStrategy()
-});

package/src/entities/account/account.ts

@@ -1,24 +0,0 @@
-import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, BeforeInsert } from 'typeorm';
-import { SharableStatus } from '@orm/entities/sharableStatus';
-const shortid = require('shortid');
-
-@Entity()
-export class Account {
-  @PrimaryGeneratedColumn()
-  id!: number;
-
-  @Column({ type: 'varchar', unique: true })
-  id_text!: string;
-
-  @Column({ type: 'boolean', default: false })
-  verified!: boolean;
-
-  @ManyToOne(() => SharableStatus, sharableStatus => sharableStatus.id)
-  @JoinColumn({ name: 'sharable_status_id' })
-  sharable_status!: SharableStatus;
-
-  @BeforeInsert()
-  generateIdText() {
-    this.id_text = shortid.generate();
-  }
-}

package/src/entities/account/accountAdminRoles.ts

@@ -1,18 +0,0 @@
-import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn } from 'typeorm';
-import { Account } from '@orm/entities/account/account';
-
-@Entity()
-export class AccountAdminRoles {
-  @PrimaryGeneratedColumn()
-  id!: number;
-
-  @ManyToOne(() => Account, account => account.id, { onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'account_id' })
-  account!: Account;
-
-  @Column({ type: 'boolean', default: false })
-  dev_admin!: boolean;
-
-  @Column({ type: 'boolean', default: false })
-  podping_admin!: boolean;
-}