@strapi/strapi 4.0.0-next.6 → 4.0.0

package/lib/factories.d.ts

@@ -0,0 +1,48 @@
+import { Service } from './core-api/service';
+import { Controller } from './core-api/controller';
+import { Middleware } from './middlewares';
+import { Policy } from './core/registries/policies';
+
+type ControllerConfig = Controller;
+
+type ServiceConfig = Service;
+
+type HandlerConfig = {
+  auth: false | { scope: string[] };
+  policies: Array<string | Policy>;
+  middlewares: Array<string | Middleware>;
+};
+
+type SingleTypeRouterConfig = {
+  find: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
+};
+
+type CollectionTypeRouterConfig = {
+  find: HandlerConfig;
+  findOne: HandlerConfig;
+  create: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
+};
+
+type RouterConfig = {
+  prefix: string;
+  only: string[];
+  except: string[];
+  config: SingleTypeRouterConfig | CollectionTypeRouterConfig;
+};
+
+interface Route {
+  method: string;
+  path: string;
+}
+interface Router {
+  prefix: string;
+  routes: Route[];
+}
+
+export function createCoreRouter(uid: string, cfg: RouterConfig): () => Router;
+export function createCoreController(uid: string, cfg: ControllerConfig): () => Controller;
+export function createCoreService(uid: string, cfg: ServiceConfig): () => Service;

package/lib/factories.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { pipe, omit, pick } = require('lodash/fp');
+
+const { createController } = require('./core-api/controller');
+const { createService } = require('./core-api/service');
+const { createRoutes } = require('./core-api/routes');
+
+const createCoreController = (uid, cfg = {}) => {
+  return ({ strapi }) => {
+    const baseController = createController({
+      contentType: strapi.contentType(uid),
+    });
+
+    let userCtrl = typeof cfg === 'function' ? cfg({ strapi }) : cfg;
+
+    for (const methodName of Object.keys(baseController)) {
+      if (userCtrl[methodName] === undefined) {
+        userCtrl[methodName] = baseController[methodName];
+      }
+    }
+
+    Object.setPrototypeOf(userCtrl, baseController);
+    return userCtrl;
+  };
+};
+
+const createCoreService = (uid, cfg = {}) => {
+  return ({ strapi }) => {
+    const baseService = createService({
+      contentType: strapi.contentType(uid),
+    });
+
+    let userService = typeof cfg === 'function' ? cfg({ strapi }) : cfg;
+
+    for (const methodName of Object.keys(baseService)) {
+      if (userService[methodName] === undefined) {
+        userService[methodName] = baseService[methodName];
+      }
+    }
+
+    Object.setPrototypeOf(userService, baseService);
+    return userService;
+  };
+};
+
+const createCoreRouter = (uid, cfg = {}) => {
+  const { prefix, config = {}, only, except } = cfg;
+  let routes;
+
+  return {
+    get prefix() {
+      return prefix;
+    },
+    get routes() {
+      if (!routes) {
+        const contentType = strapi.contentType(uid);
+
+        const defaultRoutes = createRoutes({ contentType });
+
+        Object.keys(defaultRoutes).forEach(routeName => {
+          const defaultRoute = defaultRoutes[routeName];
+
+          Object.assign(defaultRoute.config, config[routeName] || {});
+        });
+
+        const selectedRoutes = pipe(
+          routes => (except ? omit(except, routes) : routes),
+          routes => (only ? pick(only, routes) : routes)
+        )(defaultRoutes);
+
+        routes = Object.values(selectedRoutes);
+      }
+
+      return routes;
+    },
+  };
+};
+
+module.exports = {
+  createCoreController,
+  createCoreService,
+  createCoreRouter,
+};

package/lib/index.d.ts

@@ -1,40 +1,15 @@
 import { Database } from '@strapi/database';
-import { Strapi } from './Strapi';
+import { EntityService } from './services/entity-service';
+import { Strapi as StrapiClass } from './Strapi';
 
-type ID = number | string;
-
-interface Options<T> {
-  params: Params<T>;
-}
-
-interface Params<T> {
-  fields: (keyof T)[];
-}
-
-interface EntityService {
-  uploadFiles<T extends keyof AllTypes>(uid: T);
-  wrapOptions<T extends keyof AllTypes>(uid: T);
-
-  find<T extends keyof AllTypes>(uid: T): Promise<AllTypes[T][]>;
-  findPage<T extends keyof AllTypes>(uid: T): Promise<any>;
-  findWithRelationCounts<T extends keyof AllTypes>(uid: T): Promise<any>;
-  findOne<T extends keyof AllTypes>(
-    uid: T,
-    id: ID,
-    opts: Options<AllTypes[T]>
-  ): Promise<AllTypes[T]>;
-
-  count<T extends keyof AllTypes>(uid: T): Promise<any>;
-  create<T extends keyof AllTypes>(uid: T): Promise<any>;
-  update<T extends keyof AllTypes>(uid: T): Promise<any>;
-  delete<T extends keyof AllTypes>(uid: T): Promise<any>;
-}
-
-interface StrapiInterface extends Strapi {
+export * as factories from './factories';
+interface StrapiInterface extends StrapiClass {
   query: Database['query'];
   entityService: EntityService;
 }
 
+export type Strapi = StrapiInterface;
+
 declare global {
   interface AllTypes {}
 }
@@ -44,5 +19,9 @@ declare global {
     strapi: StrapiInterface;
   }
 
+  export type Strapi = StrapiInterface;
+
   const strapi: StrapiInterface;
 }
+
+export default function(opts): Strapi;

package/lib/index.js

@@ -1,3 +1,7 @@
 'use strict';
 
-module.exports = require('./Strapi');
+const Strapi = require('./Strapi');
+
+Strapi.factories = require('./factories');
+
+module.exports = Strapi;

package/lib/middlewares/body.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { defaultsDeep } = require('lodash/fp');
+const body = require('koa-body');
+
+const defaults = {
+  multipart: true,
+  patchKoa: true,
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => {
+  const bodyConfig = defaultsDeep(defaults, config);
+
+  return async (ctx, next) => {
+    // TODO: find a better way later
+    if (ctx.url === '/graphql') {
+      return next();
+    }
+
+    try {
+      await body({ patchKoa: true, ...bodyConfig })(ctx, next);
+    } catch (e) {
+      if ((e || {}).message && e.message.includes('maxFileSize exceeded')) {
+        return ctx.payloadTooLarge('FileTooBig');
+      }
+
+      throw e;
+    }
+  };
+};

package/lib/middlewares/compression.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const compress = require('koa-compress');
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => compress(config);

package/lib/middlewares/cors.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { defaultsDeep } = require('lodash/fp');
+const cors = require('@koa/cors');
+
+const defaults = {
+  origin: '*',
+  maxAge: 31536000,
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'],
+  headers: ['Content-Type', 'Authorization', 'Origin', 'Accept'],
+  keepHeadersOnError: false,
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => {
+  const {
+    origin,
+    expose,
+    maxAge,
+    credentials,
+    methods,
+    headers,
+    keepHeadersOnError,
+  } = defaultsDeep(defaults, config);
+
+  return cors({
+    async origin(ctx) {
+      let originList;
+
+      if (typeof origin === 'function') {
+        originList = await origin(ctx);
+      } else {
+        originList = origin;
+      }
+
+      const whitelist = Array.isArray(originList) ? originList : originList.split(/\s*,\s*/);
+
+      const requestOrigin = ctx.accept.headers.origin;
+      if (whitelist.includes('*')) {
+        return '*';
+      }
+
+      if (!whitelist.includes(requestOrigin)) {
+        return ctx.throw(`${requestOrigin} is not a valid origin`);
+      }
+      return requestOrigin;
+    },
+    exposeHeaders: expose,
+    maxAge,
+    credentials,
+    allowMethods: methods,
+    allowHeaders: headers,
+    keepHeadersOnError,
+  });
+};

package/lib/middlewares/errors.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { HttpError, ApplicationError } = require('@strapi/utils').errors;
+const {
+  formatApplicationError,
+  formatHttpError,
+  formatInternalError,
+} = require('../services/errors');
+
+module.exports = (/* _, { strapi } */) => {
+  return async (ctx, next) => {
+    try {
+      await next();
+
+      if (!ctx.response._explicitStatus) {
+        return ctx.notFound();
+      }
+    } catch (error) {
+      if (error instanceof ApplicationError) {
+        const { status, body } = formatApplicationError(error);
+        ctx.status = status;
+        ctx.body = body;
+        return;
+      }
+
+      if (error instanceof HttpError) {
+        const { status, body } = formatHttpError(error);
+        ctx.status = status;
+        ctx.body = body;
+        return;
+      }
+
+      strapi.log.error(error);
+
+      const { status, body } = formatInternalError(error);
+      ctx.status = status;
+      ctx.body = body;
+    }
+  };
+};

package/lib/middlewares/favicon.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { resolve } = require('path');
+const { defaultsDeep } = require('lodash/fp');
+const favicon = require('koa-favicon');
+
+const defaults = {
+  path: 'favicon.ico',
+  maxAge: 86400000,
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = (config, { strapi }) => {
+  const { maxAge, path: faviconPath } = defaultsDeep(defaults, config);
+
+  return favicon(resolve(strapi.dirs.root, faviconPath), { maxAge });
+};

package/lib/middlewares/index.d.ts

@@ -0,0 +1,5 @@
+import { Strapi } from '../';
+import { Middleware } from 'koa';
+
+export type MiddlewareFactory = (config: any, ctx: { strapi: Strapi }) => Middleware | null;
+export type Middleware = Middleware;

package/lib/middlewares/index.js

@@ -1,120 +1,33 @@
 'use strict';
 
-const { uniq, difference, get, isUndefined, merge } = require('lodash');
-
-const requiredMiddlewares = [
-  'responses',
-  'router',
-  'logger',
-  'boom',
-  'cors',
-  'cron',
-  'xframe',
-  'xss',
-  'public',
-  'favicon',
-];
-
-module.exports = async function() {
-  /** Utils */
-  const middlewareConfig = this.config.middleware;
-
-  // check if a middleware exists
-  const middlewareExists = key => {
-    return !isUndefined(this.middleware[key]);
-  };
-
-  // check if a middleware is enabled
-  const middlewareEnabled = key => {
-    return (
-      requiredMiddlewares.includes(key) ||
-      get(middlewareConfig, ['settings', key, 'enabled'], false) === true
-    );
-  };
-
-  // list of enabled middlewares
-  const enabledMiddlewares = Object.keys(this.middleware).filter(middlewareEnabled);
-
-  // Method to initialize middlewares and emit an event.
-  const initialize = middlewareKey => {
-    if (this.middleware[middlewareKey].loaded === true) return;
-
-    const module = this.middleware[middlewareKey].load;
-
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(`(middleware: ${middlewareKey}) is taking too long to load.`),
-        middlewareConfig.timeout || 1000
-      );
-
-      this.middleware[middlewareKey] = merge(this.middleware[middlewareKey], module);
-
-      Promise.resolve()
-        .then(() => module.initialize())
-        .then(() => {
-          clearTimeout(timeout);
-          this.middleware[middlewareKey].loaded = true;
-          resolve();
-        })
-        .catch(err => {
-          clearTimeout(timeout);
-
-          if (err) {
-            return reject(err);
-          }
-        });
-    });
-  };
-
-  /**
-   * Run init functions
-   */
-
-  // Run beforeInitialize of every middleware
-  await Promise.all(
-    enabledMiddlewares.map(key => {
-      const { beforeInitialize } = this.middleware[key].load;
-      if (typeof beforeInitialize === 'function') {
-        return beforeInitialize();
-      }
-    })
-  );
-
-  // run the initialization of an array of middlewares sequentially
-  const initMiddlewaresSeq = async middlewareArr => {
-    for (let key of uniq(middlewareArr)) {
-      await initialize(key);
-    }
-  };
-
-  const middlewaresBefore = get(middlewareConfig, 'load.before', [])
-    .filter(middlewareExists)
-    .filter(middlewareEnabled);
-
-  const middlewaresAfter = get(middlewareConfig, 'load.after', [])
-    .filter(middlewareExists)
-    .filter(middlewareEnabled);
-
-  const middlewaresOrder = get(middlewareConfig, 'load.order', [])
-    .filter(middlewareExists)
-    .filter(middlewareEnabled);
-
-  const unspecifiedMiddlewares = difference(
-    enabledMiddlewares,
-    middlewaresBefore,
-    middlewaresOrder,
-    middlewaresAfter
-  );
-
-  // before
-  await initMiddlewaresSeq(middlewaresBefore);
-
-  // ordered // rest of middlewares
-  await Promise.all([
-    initMiddlewaresSeq(middlewaresOrder),
-    Promise.all(unspecifiedMiddlewares.map(initialize)),
-  ]);
-
-  // after
-  await initMiddlewaresSeq(middlewaresAfter);
+const compression = require('./compression');
+const cors = require('./cors');
+const errors = require('./errors');
+const favicon = require('./favicon');
+const ip = require('./ip');
+const logger = require('./logger');
+const poweredBy = require('./powered-by');
+const body = require('./body');
+const query = require('./query');
+const responseTime = require('./response-time');
+const responses = require('./responses');
+const security = require('./security');
+// TODO: add back ?
+// session: require('./session'),
+const publicStatic = require('./public');
+
+module.exports = {
+  errors,
+  ip,
+  security,
+  cors,
+  responseTime,
+  poweredBy,
+  logger,
+  compression,
+  responses,
+  body,
+  query,
+  favicon,
+  public: publicStatic,
 };

package/lib/middlewares/ip.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const ip = require('koa-ip');
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => ip(config);

package/lib/middlewares/logger.js

@@ -0,0 +1,27 @@
+'use strict';
+const chalk = require('chalk');
+
+const codeToColor = code => {
+  return code >= 500
+    ? chalk.red(code)
+    : code >= 400
+    ? chalk.yellow(code)
+    : code >= 300
+    ? chalk.cyan(code)
+    : code >= 200
+    ? chalk.green(code)
+    : code;
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = (_, { strapi }) => {
+  return async (ctx, next) => {
+    const start = Date.now();
+    await next();
+    const delta = Math.ceil(Date.now() - start);
+
+    strapi.log.http(`${ctx.method} ${ctx.url} (${delta} ms) ${codeToColor(ctx.status)}`);
+  };
+};

package/lib/middlewares/powered-by.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { defaultsDeep } = require('lodash/fp');
+
+const defaults = {
+  poweredBy: 'Strapi <strapi.io>',
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => {
+  const { poweredBy } = defaultsDeep(defaults, config);
+
+  return async (ctx, next) => {
+    await next();
+
+    ctx.set('X-Powered-By', poweredBy);
+  };
+};