@reachu/database 1.0.0

package/src/repositories/shipping/index.ts

@@ -0,0 +1,15 @@
+import { Repository, EntityRepository } from 'typeorm';
+
+import ProductShipping from '../../entity/modules/shipping/ProductShipping';
+import Shipping from '../../entity/modules/shipping/Shipping';
+import ShippingCountry from '../../entity/modules/shipping/ShippingCountry';
+
+
+@EntityRepository(ProductShipping)
+export class ProductShippingRepository extends Repository<ProductShipping> {}
+
+@EntityRepository(Shipping)
+export class ShippingRepository extends Repository<Shipping> {}
+
+@EntityRepository(ShippingCountry)
+export class ShippingCountryRepository extends Repository<ShippingCountry> {}

package/src/repositories/shopcart/index.ts

@@ -0,0 +1,25 @@
+import { Repository, EntityRepository } from 'typeorm';
+import Cart from '../../entity/modules/shopcart/Cart';
+import CartItem from '../../entity/modules//shopcart/CartItem';
+import Checkout from '../../entity/modules//shopcart/Checkout';
+import {CheckoutBillingAddress} from '../../entity/modules//shopcart/CheckoutBillingAddress';
+import {CheckoutShippingAddress} from '../../entity/modules//shopcart/CheckoutShippingAddress';
+import {PriceData} from '../../entity/modules//shopcart/PriceData';
+
+@EntityRepository(Cart)
+export class CartRepository extends Repository<Cart> {}
+
+@EntityRepository(CartItem)
+export class CartItemRepository extends Repository<CartItem> {}
+
+@EntityRepository(Checkout)
+export class CheckoutRepository extends Repository<Checkout> {}
+
+@EntityRepository(CheckoutBillingAddress)
+export class CheckoutBillingAddressRepository extends Repository<CheckoutBillingAddress> {}
+
+@EntityRepository(CheckoutShippingAddress)
+export class CheckoutShippingAddressRepository extends Repository<CheckoutShippingAddress> {}
+
+@EntityRepository(PriceData)
+export class PriceDataRepository extends Repository<PriceData> {}

package/src/staticData/ChannelName.ts

@@ -0,0 +1,8 @@
+export default {
+  SHOPIFY: 'Shopify',
+  WOO: 'Woocommerce',
+  FACEBOOK: 'Facebook',
+  SQUARESPACE: 'Squarespace',
+  WORDPRESS: 'Wordpress',
+  MAGENTO: 'Magento',
+};

package/src/staticData/ConnectionType.ts

@@ -0,0 +1,4 @@
+export default {
+  IMPORT: 'import',
+  EXPORT: 'export',
+};

package/src/staticData/Currency.ts

@@ -0,0 +1,11 @@
+enum Currency {
+  EUR = 'EUR',
+  NOK = 'NOK',
+  USD = 'USD',
+  GBP = 'GBP',
+  ARS = 'ARS',
+}
+
+export const currencies = [Currency.EUR, Currency.NOK, Currency.USD, Currency.GBP];
+
+export default Currency;

package/src/staticData/OrderStatus.ts

@@ -0,0 +1,41 @@
+export class OrderStatus {
+  static readonly PENDING = new OrderStatus('PENDING', false);
+  static readonly AUTHORIZE = new OrderStatus('AUTHORIZE', true);
+  static readonly PROCESSING = new OrderStatus('PROCESSING', true);
+  static readonly COMPLETED = new OrderStatus('COMPLETED', false);
+  static readonly FAILED = new OrderStatus('FAILED', false);
+  static readonly CANCELED = new OrderStatus('CANCELED', false);
+  static readonly REFUNDED = new OrderStatus('REFUNDED', false);
+  static readonly DELIVERED = new OrderStatus('DELIVERED', false);
+  static readonly RETURNED = new OrderStatus('RETURNED', false);
+  static readonly RETURN_APPROVED = new OrderStatus('RETURN_APPROVED', false);
+  static readonly RETURN_DECLINED = new OrderStatus('RETURN_DECLINED', false);
+
+  private constructor(public readonly name: string, public readonly cancellable: boolean) {}
+
+  static get values(): OrderStatus[] {
+    return [
+      this.PENDING,
+      this.AUTHORIZE,
+      this.PROCESSING,
+      this.COMPLETED,
+      this.FAILED,
+      this.CANCELED,
+      this.REFUNDED,
+      this.DELIVERED,
+      this.RETURNED,
+      this.RETURN_APPROVED,
+      this.RETURN_DECLINED,
+    ];
+  }
+
+  static fromString(string: string): OrderStatus {
+    const value = (this as any)[string];
+    if (value) {
+      return value;
+    }
+    throw new Error(
+      `Illegal argument passed to fromString(): ${string} does not correspond to any instance of the enum VippsPaymentStatus`,
+    );
+  }
+}

package/src/staticData/PaymentProcessor.ts

@@ -0,0 +1,9 @@
+enum PaymentProcessor {
+  Stripe = 'STRIPE',
+  Klarna = 'KLARNA',
+  Shopify = 'SHOPIFY',
+  Woocommerce = 'Woocommerce',
+  Vipps = 'VIPPS',
+}
+
+export default PaymentProcessor;

package/src/staticData/ProductOrigin.ts

@@ -0,0 +1,19 @@
+const origins = {
+  SHOPIFY: 'SHOPIFY',
+  WOOCOMMERCE: 'WOOCOMMERCE',
+  OUTSHIFTER: 'OUTSHIFTER',
+  SQUARESPACE: 'SQUARESPACE',
+  MAGENTO: 'MAGENTO',
+};
+
+export const externals = [
+  origins.SHOPIFY,
+  origins.WOOCOMMERCE,
+  origins.SQUARESPACE,
+  origins.MAGENTO,
+];
+
+export default {
+  ...origins,
+  externals,
+};

package/src/staticData/TrackingProcessor.ts

@@ -0,0 +1,8 @@
+enum TrackingProcessor {
+  Shopify = 'SHOPIFY',
+  Aftership = 'AFTERSHIP',
+  Magento = 'MAGENTO',
+  Woo = 'WOO',
+}
+
+export default TrackingProcessor;

package/src/staticData/VippsPaymentStatus.ts

@@ -0,0 +1,41 @@
+export class VippsPaymentStatus {
+  static readonly RESERVE = new VippsPaymentStatus('RESERVE');
+  static readonly RESERVED = new VippsPaymentStatus('RESERVED');
+  static readonly SALE = new VippsPaymentStatus('SALE');
+  static readonly RESERVE_FAILED = new VippsPaymentStatus('RESERVE_FAILED');
+  static readonly SALE_FAILED = new VippsPaymentStatus('SALE_FAILED');
+  static readonly CANCELLED = new VippsPaymentStatus('CANCELLED');
+  static readonly REJECTED = new VippsPaymentStatus('REJECTED');
+
+  private constructor(public readonly name: string) {}
+
+  static get values(): VippsPaymentStatus[] {
+    return [
+      this.RESERVE, // Payment reserved, by user accepting the payment in Vipps
+      this.RESERVED, // Payment reserved, by user accepting the payment in Vipps
+      this.SALE, // Payment captured with direct capture, by merchant (after RESERVED)
+      this.RESERVE_FAILED, // Reserve failed because of insufficient funds, invalid card, or similar
+      this.SALE_FAILED, // Direct failed because of insufficient funds, invalid card, or similar
+      this.CANCELLED, // Payment canceled, by user in Vipps
+      this.REJECTED, // User did not act on the payment (timeout, etc)
+    ];
+  }
+
+  static fromString(string: string): VippsPaymentStatus {
+    const value = (this as any)[string];
+    if (value) {
+      return value;
+    }
+    throw new Error(
+      `Illegal argument passed to fromString(): ${string} does not correspond to any instance of the enum VippsPaymentStatus`,
+    );
+  }
+
+  static isReserve(string: string): boolean {
+    return [this.RESERVE.name, this.RESERVED.name].includes(string);
+  }
+
+  static isFailed(string: string): boolean {
+    return [this.RESERVE_FAILED.name, this.CANCELLED.name, this.REJECTED.name].includes(string);
+  }
+}

package/src/staticData/index.ts

@@ -0,0 +1,20 @@
+import ProductOrigin from '../staticData/ProductOrigin';
+import ChannelName from '../staticData/ChannelName';  
+import PaymentProcessor from '../staticData/PaymentProcessor';
+import TrackingProcessor from '../staticData/TrackingProcessor';
+import Currency from '../staticData/Currency';
+import { VippsPaymentStatus } from '../staticData/VippsPaymentStatus';
+import { OrderStatus } from '../staticData/OrderStatus';
+import ConnectionType from '../staticData/ConnectionType';
+
+
+export {
+  ProductOrigin,
+  ChannelName,
+  PaymentProcessor,
+  TrackingProcessor,
+  Currency,
+  VippsPaymentStatus,
+  OrderStatus,
+  ConnectionType
+};

package/src/subscribers/ProductSubscriber.ts

@@ -0,0 +1,25 @@
+import { EntitySubscriberInterface, EventSubscriber, RemoveEvent, UpdateEvent } from 'typeorm';
+import { Product } from '../entity/Product.entity';
+import { logger } from '@reachu/logger';
+
+@EventSubscriber()
+export class ProductSubscriber implements EntitySubscriberInterface<Product> {
+  static invalidateCache: (key: any) => Promise<void>;
+  listenTo = () => Product;
+
+  afterUpdate = async (event: UpdateEvent<Product>) => {
+    if (event?.entity) {
+      logger.debug(`[ProductSubscriber.afterUpdate] after update entity (${event.entity.id})`);
+      const { id } = event.entity;
+      await Product.invalidateCache(id, ProductSubscriber.invalidateCache);
+    }
+  };
+
+  afterRemove = async (event: RemoveEvent<Product>) => {
+    if (event?.entity) {
+      logger.debug(`[ProductSubscriber.afterUpdate] after remove entity (${event.entity.id})`);
+      const { id } = event.entity;
+      await Product.invalidateCache(id, ProductSubscriber.invalidateCache);
+    }
+  };
+}

package/src/subscribers/UserSubscriber.ts

@@ -0,0 +1,23 @@
+import { EntitySubscriberInterface, EventSubscriber, RemoveEvent, UpdateEvent } from 'typeorm';
+import { logger } from '@reachu/logger';
+import { User } from '../entity';
+
+@EventSubscriber()
+export class UserSubscriber implements EntitySubscriberInterface<User> {
+  static invalidateCache: (key: any) => Promise<void>;
+  listenTo = () => User;
+
+  afterUpdate = async (event: UpdateEvent<User>) => {
+    if (event.entity) {
+      logger.debug(`[UserSubscriber.afterUpdate] after update entity (${event?.entity?.id})`);
+      const { id } = event.entity;
+      User.invalidateCache(id, UserSubscriber.invalidateCache);
+    }
+  };
+
+  afterRemove = async (event: RemoveEvent<User>) => {
+    logger.debug(`[UserSubscriber.afterUpdate] after remove entity (${event?.entity?.id})`);
+    const { id } = event.entity;
+    User.invalidateCache(id, UserSubscriber.invalidateCache);
+  };
+}

package/src/subscribers/index.ts

@@ -0,0 +1,4 @@
+import { ProductSubscriber } from './ProductSubscriber';
+import { UserSubscriber } from './UserSubscriber';
+
+export { ProductSubscriber, UserSubscriber };

package/src/utils/index.ts

@@ -0,0 +1,88 @@
+import { ConnectionConfig } from '../interface/connectionConfig';
+
+import { EntitySchema, MigrationInterface, Connection, EntitySubscriberInterface } from 'typeorm';
+import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
+import * as Entity from '../entity';
+import * as Migration from '../migrations';
+import * as Repository from '../repositories';
+import * as Subscriber from '../subscribers';
+
+export const getEntities = (): EntitySchema<any>[] => {
+  const entities = [];
+  for (const key in Entity) {
+    if (Entity.hasOwnProperty(key)) {
+      const entity = Entity[key];
+      entities.push(entity);
+    }
+  }
+  return entities;
+};
+
+export const getMigrations = (): MigrationInterface[] => {
+  const migrations = [];
+  for (const key in Migration) {
+    if (Migration.hasOwnProperty(key)) {
+      const migration = Migration[key];
+      migrations.push(migration);
+    }
+  }
+  return migrations;
+};
+
+export const getRepositories = (): EntitySchema<any>[] => {
+  const repositories = [];
+  for (const key in Repository) {
+    if (Repository.hasOwnProperty(key)) {
+      const repository = Repository[key];
+      repositories.push(repository);
+    }
+  }
+  return repositories;
+};
+
+export const getSubscribers = (
+  removeCache: (key: any) => Promise<void> | null,
+): EntitySubscriberInterface<any>[] => {
+  const subscribers = [];
+  if (!removeCache) {
+    return subscribers;
+  }
+  for (const key in Subscriber) {
+    if (Subscriber.hasOwnProperty(key)) {
+      const subscriber = Subscriber[key];
+      subscriber.invalidateCache = removeCache;
+      subscribers.push(subscriber);
+    }
+  }
+  return subscribers;
+};
+
+export const getConnectionConfig = (
+  config: {
+    cache: {
+      remove: (key: any) => Promise<void>;
+    };
+  } = { cache: { remove: null } },
+): ConnectionConfig => {
+  return {
+    type: process.env.DB_TYPE,
+    host: process.env.DB_HOST,
+    port: +process.env.DB_PORT,
+    username: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_NAME,
+    namingStrategy: new SnakeNamingStrategy(),
+    entities: getEntities(),
+    synchronize: false,
+    timezone: 'Z',
+    migrations: getMigrations(),
+    subscribers: getSubscribers(config.cache.remove),
+  };
+};
+
+export const cleanDatabase = async (connection: Connection) => {
+  await connection.dropDatabase();
+  return connection.synchronize(true);
+};
+
+export const closeDatabase = (connection: Connection) => connection.close();

package/test/setup.ts

@@ -0,0 +1,4 @@
+import path from 'path';
+import dotenv from 'dotenv';
+
+dotenv.config({ path: path.resolve(process.cwd(), '.env.test') });

package/test/utils.test.ts

@@ -0,0 +1,22 @@
+import { getEntities, getMigrations, getRepositories } from '../src/utils';
+
+describe('Utils Tests', () => {
+  describe('getEntities', () => {
+    test('get all entities', () => {
+      const entities = getEntities();
+      expect(entities.length).toBeGreaterThan(0);
+    });
+  });
+  describe('getMigrations', () => {
+    test('get all migrations', () => {
+      const migrations = getMigrations();
+      expect(migrations.length).toBeGreaterThan(0);
+    });
+  });
+  describe('getRepositories', () => {
+    test('get all repositories', () => {
+      const repositories = getRepositories();
+      expect(repositories.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "node_modules",
+    "test",
+    "dist",
+    "**/*spec.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "target": "ES6",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "allowJs": true,
+    "incremental": true
+  },
+  "include": ["src/**/*", "typings/*"]
+}