cc-core-cli 1.0.0

package/template/src/main.ts

@@ -0,0 +1,299 @@
+import * as dotenv from "dotenv";
+dotenv.config();
+require("newrelic");
+const now = require("performance-now");
+import { Reflector } from "@nestjs/core";
+
+import * as _ from "lodash";
+
+import { v4 as uuid } from "uuid";
+import * as rTracer from "cls-rtracer";
+import { NestFactory } from "@nestjs/core";
+import {
+  FastifyAdapter,
+  NestFastifyApplication
+} from "@nestjs/platform-fastify";
+import { AppModule } from "./app.module";
+import { join } from "path";
+import { AppClusterService } from "./app_cluster.service";
+import { CUSTOM_MODULES as LIB_CUSTOM_MODULES } from 'cc-core-lib/module'
+import { Logger } from "@nestjs/common";
+import {
+  IGNORE_ENDPOINT_PATHS,
+  CONST,
+  EntitiesService,
+  TemplateService,
+  SettingService,
+  TranslateService,
+  AllExceptionsFilter,
+  AuthService,
+  UserRolePermissonService,
+  UserRoleService,
+  UserService,
+  ActivityLogService,
+  DeployLogService,
+  ImportExportLogService,
+  LanguageService,
+  ImportExportService,
+  AttachmentService,
+  CommentDataService,
+  AddressService,
+  CountryService,
+  DistrictService,
+  ProvinceService,
+  SubdistrictService,
+  TimeZoneService,
+  CompanyService,
+  DeployDestinationService,
+  DeployPackageService,
+  CustomFunctionService,
+  SFTPSettingService,
+  SftpLogService,
+  SmsService,
+  ReasonDataService,
+  ReasonMasterService,
+  ReasonOptionService,
+  WidgetService,
+  VersionDataService,
+  ScheduleActionService,
+  ScheduleLogService,
+  MapLocationService,
+  MailSettingService,
+  MailLogService,
+  request,
+  SmsLogService,
+  ExecutionLogService,
+  initialCustomModules,
+  initialCustomProviders,
+  initialSettingLayouts,
+  NotificationSubscriptionService,
+  NotificationMessageService,
+  NotificationMessageQueueService,
+  NotificationLogService,
+  ShortlyUrlService,
+  LayoutShareWidgetService,
+  ReportReportService,
+  ApiKeyService,
+  JWTAuthGuard,
+  CsrfGuard,
+  CacheInterceptor
+} from 'cc-core-lib/core'
+
+import { CUSTOM_MODULES } from "src/modules/modules";
+import * as packageData from "../package.json";
+
+async function initialService(app: NestFastifyApplication, serviceClass: any) {
+  let start = now();
+  const service = await app.resolve<typeof serviceClass>(serviceClass);
+  await service.init();
+  let end = now();
+  Logger.log(
+    `${service.constructor.name} initial done (${(end - start).toFixed(3)})`,
+    "MAIN"
+  );
+}
+
+async function refreshService(app: NestFastifyApplication, serviceClass: any) {
+  let start = now();
+  const service = await app.resolve<typeof serviceClass>(serviceClass);
+  await service.initRefresh();
+  let end = now();
+  Logger.log(
+    `${service.constructor.name} initial refresh done (${(end - start).toFixed(
+      3
+    )})`,
+    "MAIN"
+  );
+}
+
+async function initialCustomService(app: NestFastifyApplication) {
+  const SPECIFY_CUSTOM_MODULES =
+    process.env.CUSTOM_MODULES === "" ||
+      process.env.CUSTOM_MODULES === undefined
+      ? []
+      : process.env.CUSTOM_MODULES.split(",");
+  const RUN_CUSTOM_SERVICES = [];
+  SPECIFY_CUSTOM_MODULES.length === 0
+    ? CUSTOM_MODULES.forEach(c => {
+      RUN_CUSTOM_SERVICES.push(...(c.services || []));
+    })
+    : CUSTOM_MODULES.filter(c =>
+      SPECIFY_CUSTOM_MODULES.includes(c.module.name)
+    ).forEach(c => {
+      RUN_CUSTOM_SERVICES.push(...(c.services || []));
+    });
+  for (const customService of RUN_CUSTOM_SERVICES) {
+    await initialService(app, customService);
+  }
+}
+
+async function initial(app: NestFastifyApplication) {
+
+  LIB_CUSTOM_MODULES.push(...CUSTOM_MODULES)
+
+  await initialService(app, ApiKeyService);
+  await initialService(app, SettingService);
+  await initialService(app, EntitiesService);
+  await initialService(app, UserRolePermissonService);
+  await initialService(app, UserRoleService);
+  await initialService(app, UserService);
+  await initialService(app, LanguageService);
+  await initialService(app, TranslateService);
+  await initialService(app, ActivityLogService);
+  await initialService(app, TemplateService);
+  await initialService(app, AttachmentService);
+
+  await initialService(app, TimeZoneService);
+  await initialService(app, CountryService);
+  await initialService(app, ProvinceService);
+  await initialService(app, DistrictService);
+  await initialService(app, SubdistrictService);
+  await initialService(app, AddressService);
+  await initialService(app, CompanyService);
+
+  await initialService(app, SFTPSettingService);
+  await initialService(app, SftpLogService);
+  await initialService(app, MailSettingService);
+  await initialService(app, MailLogService);
+  await initialService(app, SmsLogService);
+  await initialService(app, SmsService);
+
+  await initialService(app, ReasonMasterService);
+  await initialService(app, ReasonOptionService);
+  await initialService(app, ReasonDataService);
+
+  await initialService(app, ReportReportService);
+
+  await initialService(app, WidgetService);
+  await initialService(app, MapLocationService);
+  await initialService(app, VersionDataService);
+  await initialService(app, CommentDataService);
+
+  await initialService(app, ScheduleLogService);
+  await initialService(app, ScheduleActionService);
+
+  await initialService(app, NotificationSubscriptionService);
+  await initialService(app, NotificationMessageService);
+  await initialService(app, NotificationMessageQueueService);
+  await initialService(app, NotificationLogService);
+
+  await initialService(app, ShortlyUrlService);
+
+  await initialService(app, DeployDestinationService);
+  await initialService(app, DeployPackageService);
+  await initialService(app, DeployLogService);
+
+  await initialService(app, CustomFunctionService);
+
+  await initialService(app, ExecutionLogService);
+
+  await initialService(app, LayoutShareWidgetService);
+
+  await initialCustomModules();
+  await initialCustomProviders();
+  await initialSettingLayouts();
+
+  await initialCustomService(app);
+
+  await initialService(app, ImportExportService);
+  await initialService(app, ImportExportLogService);
+
+  await initialService(app, EntitiesService);
+  await refreshService(app, EntitiesService);
+  await refreshService(app, ScheduleActionService);
+  await refreshService(app, SettingService);
+}
+
+async function bootstrap() {
+  dotenv.config();
+  // const whitelist = _.concat(["0.0.0.0", "127.0.0.1"], [`${process.env.LOOP_BACK_IP}`]);
+  const fastify = new FastifyAdapter({ logger: true, bodyLimit: 104857600 });
+  // fastify.register(require("fastify-rate-limit"), {
+  //   whitelist,
+  //   timeWindow: 15 * 60 * 1000, // 15 minutes
+  //   max: 100 // limit each IP to 100 requests per windowMs
+  // });
+  fastify.register(require("@fastify/cors"), {
+    // put your options here
+  });
+  fastify.register(require("fastify-xml-body-parser"));
+
+  // fastify.register(require("fastify-raw-body"), {
+  //   field: 'rawBody', // change the default request.rawBody property name
+  //   global: false, // add the rawBody to every request. **Default true**
+  //   encoding: 'utf8', // set it to false to set rawBody as a Buffer **Default utf8**
+  //   runFirst: true, // get the body before any preParsing hook change/uncompress it. **Default false**
+  //   routes: [] // array of routes, **`global`** will be ignored, wildcard routes not supported
+  // });
+
+  fastify.register(rTracer.fastifyPlugin, {
+    requestIdFactory: req => ({
+      request_id: uuid(),
+      user_ip: req.headers["client-ip"],
+      user_agent: req.headers["user-agent"]
+    })
+  });
+
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    fastify
+  );
+
+  if (process.env.SERVE_STATIC === "true") {
+    app.useStaticAssets({
+      root: join(__dirname, "../..", process.env.SERVE_STATIC_PATH),
+      prefix: `/${process.env.SERVE_STATIC_PATH}`
+    });
+  }
+
+  _.set(CONST, "app", app);
+  await initial(app);
+  // const location = await app.resolve<LocationService>(LocationService);
+  // await location.init();
+  // Logger.log(`INVENTORY LOCATION:: init `, "MAIN");
+
+  // const apiKey = await app.resolve<ApiKeyService>(ApiKeyService);
+  // await apiKey.init();
+  // Logger.log(`INIT APIKEY ENTITY`, "MAIN");
+
+  const reflector = app.get(Reflector);
+  const auth = app.get(AuthService);
+  app.useGlobalGuards(new JWTAuthGuard(reflector, auth));
+  app.useGlobalGuards(new CsrfGuard(reflector));
+  app.setGlobalPrefix("api/v1");
+  app.use(request);
+  // app.useGlobalInterceptors(new FilterInterceptor(reflector));
+  app.useGlobalInterceptors(new CacheInterceptor(reflector));
+
+  // app.enableCors();
+  app.useGlobalFilters(new AllExceptionsFilter());
+
+  const routes = [];
+  const ignoreRouteRegex = new RegExp(IGNORE_ENDPOINT_PATHS.join("|"));
+  app
+    .getHttpAdapter()
+    .getInstance()
+    .addHook("onRoute", route => {
+      if (!ignoreRouteRegex.test(route.path)) {
+        routes.push({
+          path: route.path.replace("/api/v1/", ""),
+          method: route.method
+        });
+      }
+    });
+  app
+    .getHttpAdapter()
+    .getInstance()
+    .addHook("onReady", done => {
+      CONST.ENDPOINT_PATHS = routes;
+      done();
+    });
+
+  await app.listen(parseInt(process.env.PORT, 10), "0.0.0.0");
+  CONST.HEALTH_CHECK = true;
+  CONST.SYSTEM_NAME = process.env.SYSTEM_NAME || _.get(packageData, "name");
+}
+
+AppClusterService.clusterize(bootstrap);
+// +process.env.QUEUE_CONCURRENCY > 0 || process.env.ENABLE_SCHEDULE_ACTION === "true" ? bootstrap() : AppClusterService.clusterize(bootstrap);
+// bootstrap();

package/template/src/modules/modules.ts

@@ -0,0 +1,16 @@
+/***
+ * This example structure when developer config custom module
+ * const CUSTOM_MODULES = [
+ * { module: CarriersModule, services: [CarrierCarrierService, CarrierLogService] },
+ * { module: CustomersModule, services: [CustomerService, AddressService] },
+ * { module: ProductsModule, services: [ProductService] },
+ * { module: OrdersModule, services: [ChannelService, OrderService, OrderItemService] }
+ * ];
+
+export { CUSTOM_MODULES };
+
+ */
+
+const CUSTOM_MODULES = [];
+
+export { CUSTOM_MODULES };

package/template/tsconfig.build.json

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

package/template/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "declaration": true,
+        "removeComments": true,
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        "target": "es2017",
+        "sourceMap": true,
+        "outDir": "./dist",
+        "baseUrl": "./",
+        "incremental": true,
+        "allowSyntheticDefaultImports": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+    },
+    "exclude": [
+        "node_modules",
+        "dist",
+        "media"
+    ]
+}

package/template/version.json

@@ -0,0 +1,5 @@
+{
+  "major": "1",
+  "minor": "0",
+  "patch": "0"
+}

package/template_admin/.env

@@ -0,0 +1,10 @@
+NODE_ENV=NODE_ENV
+PORT=4000
+COOKIE_SECURE=false
+COOKIE_HTTP_ONLY=false
+COOKIE_SAME_SITE=
+SYSTEM_APP_KEY=SYSTEM_APP_KEY
+SYSTEM_SECRET_KEY=SYSTEM_SECRET_KEY
+API_GATEWAY=API_GATEWAY
+API_GATEWAY_MEDIA=API_GATEWAY_MEDIA
+GOOGLE_MAP_KEY=

package/template_admin/README.md

@@ -0,0 +1,29 @@
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact

package/template_admin/config/service-account.json

@@ -0,0 +1 @@
+{}

package/template_admin/index.js

@@ -0,0 +1,63 @@
+require('dotenv').config()
+require('log-timestamp')
+const _ = require('lodash')
+const express = require('express')
+const next = require('next')
+const app = next({ dev: process.env.NODE_ENV !== 'production' })
+const handler = app.getRequestHandler()
+const cookieParser = require('cookie-parser')
+const bodyParser = require('body-parser')
+const { apis, request } = require('cc-admin-lib/server')
+
+const PORT = process.env.PORT || 3000
+
+app
+  .prepare()
+  .then(() => {
+    const server = express()
+    server.use(cookieParser())
+    server.use(bodyParser.urlencoded({
+      extended: true
+    }))
+    server.use(bodyParser.json({
+      type: 'application/json',
+      limit: '100mb'
+    }))
+    server.get('/health_check', (req, res) => {
+      res.json({ message: 'ok' })
+    })
+
+    const setAbout = async () => {
+      try {
+        await request.setAbout()
+      }
+      catch (e) {
+        console.log('setAbout error: ', e)
+      }
+    }
+    setAbout()
+
+    apis(server)
+
+    server.get(
+      '*',
+      (req, res) => {
+        req.env = {
+          ENV: process.env.NODE_ENV,
+          PORT: process.env.PORT,
+          API_GATEWAY: process.env.API_GATEWAY,
+          API_GATEWAY_MEDIA: process.env.API_GATEWAY_MEDIA,
+          API_DOCUMENT_URL: process.env.API_DOCUMENT_URL,
+          GOOGLE_MAP_KEY: process.env.GOOGLE_MAP_KEY,
+          EDITOR_LICENSE_KEY: process.env.EDITOR_LICENSE_KEY
+        }
+        return handler(req, res)
+      }
+    )
+
+    server.listen(PORT, (err) => {
+      if (err) throw err
+      console.log('Server start on port : ', PORT)
+      console.log('Start on mode : ', process.env.NODE_ENV)
+    })
+  })

package/template_admin/newrelic.js

@@ -0,0 +1,78 @@
+"use strict";
+require('dotenv').config()
+
+const ENABLE_NEW_RELIC = process.env.NEW_RELIC_APP_NAME && process.env.NEW_RELIC_LICENSE_KEY
+/**
+ * New Relic agent configuration.
+ *
+ * See lib/config/default.js in the agent distribution for a more complete
+ * description of configuration variables and their potential values.
+ */
+exports.config = {
+  agent_enabled: ENABLE_NEW_RELIC,
+  /**
+   * Array of application names.
+   */
+  app_name: [process.env.NEW_RELIC_APP_NAME],
+  /**
+   * Your New Relic license key.
+   */
+  license_key: process.env.NEW_RELIC_LICENSE_KEY,
+  /**
+   * This setting controls distributed tracing.
+   * Distributed tracing lets you see the path that a request takes through your
+   * distributed system. Enabling distributed tracing changes the behavior of some
+   * New Relic features, so carefully consult the transition guide before you enable
+   * this feature: https://docs.newrelic.com/docs/transition-guide-distributed-tracing
+   * Default is true.
+   */
+  distributed_tracing: {
+    /**
+     * Enables/disables distributed tracing.
+     *
+     * @env NEW_RELIC_DISTRIBUTED_TRACING_ENABLED
+     */
+    enabled: true,
+  },
+  logging: {
+    /**
+     * Level at which to log. 'trace' is most useful to New Relic when diagnosing
+     * issues with the agent, 'info' and higher will impose the least overhead on
+     * production applications.
+     */
+    level: "info",
+  },
+  application_logging: {
+    forwarding: {
+      enabled: true,
+    },
+  },
+  /**
+   * When true, all request headers except for those listed in attributes.exclude
+   * will be captured for all traces, unless otherwise specified in a destination's
+   * attributes include/exclude lists.
+   */
+  allow_all_headers: true,
+  attributes: {
+    /**
+     * Prefix of attributes to exclude from all destinations. Allows * as wildcard
+     * at end.
+     *
+     * NOTE: If excluding headers, they must be in camelCase form to be filtered.
+     *
+     * @env NEW_RELIC_ATTRIBUTES_EXCLUDE
+     */
+    exclude: [
+      "request.headers.cookie",
+      "request.headers.authorization",
+      "request.headers.proxyAuthorization",
+      "request.headers.setCookie*",
+      "request.headers.x*",
+      "response.headers.cookie",
+      "response.headers.authorization",
+      "response.headers.proxyAuthorization",
+      "response.headers.setCookie*",
+      "response.headers.x*",
+    ],
+  },
+};

package/template_admin/next.config.js

@@ -0,0 +1,76 @@
+require('dotenv').config()
+
+const withPlugins = require('next-compose-plugins')
+const withLess = require('next-with-less')
+const AntdDayjsWebpackPlugin = require('antd-dayjs-webpack-plugin')
+const withPWA = require('next-pwa')
+const generateTheme = require('next-dynamic-antd-theme/plugin')
+
+const prefix = '/'
+const path = require('path')
+
+
+const withAntdTheme = generateTheme({
+  antDir: path.join(__dirname, './node_modules/antd'),
+  stylesDir: path.join(__dirname, './theme'),
+  varFile: path.join(__dirname, './theme/vars.less'),
+  mainLessFile: path.join(__dirname, './theme/main.less'),
+  outputFilePath: path.join(__dirname, './.next/static/color.less')
+})
+
+const withAntd = (nextConfig = {}) => {
+  return Object.assign({}, nextConfig, {
+    onDemandEntries: {
+      maxInactiveAge: 1000 * 60 * 60,
+      pagesBufferLength: 5
+    },
+    lessLoaderOptions: {
+      javascriptEnabled: true
+    },
+    poweredByHeader: false,
+    cssModules: true,
+    cssLoaderOptions: {
+      camelCase: true,
+      localIdentName: '[local]___[hash:base64:5]',
+      getLocalIdent: (context, localIdentName, localName, options) => {
+        return localName
+      }
+    },
+  })
+}
+
+module.exports = withPlugins([
+  [withLess, {
+    lessLoaderOptions: {}
+  }],
+  [
+    withPWA, {
+      pwa: {
+        dest: 'public',
+        register: true,
+        skipWaiting: true,
+        disable: process.env.NODE_ENV === 'development'
+      }
+    }
+  ],
+  withAntd,
+  withAntdTheme,
+], {
+  serverRuntimeConfig: {},
+  publicRuntimeConfig: { prefix },
+  assetPrefix: prefix,
+  // experimental: {
+  //   //largePageDataBytes: 128 * 1000, // 128KB by default
+  //   largePageDataBytes: 128 * 100000,
+  // },
+  plugins: [
+    new AntdDayjsWebpackPlugin()
+  ],
+  generateBuildId: async () => {
+    if (process.env.BUILD_ID) {
+      console.log('Build with build id : ' + process.env.BUILD_ID)
+      return process.env.BUILD_ID
+    }
+    return null
+  }
+})