@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/services/metrics/__tests__/middleware.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const createMiddleware = require('../middleware');
+
+describe('Metrics middleware', () => {
+  test('Ignores request with extension in them', async () => {
+    const sendEvent = jest.fn();
+
+    const middleware = createMiddleware({ sendEvent });
+
+    await middleware(
+      {
+        request: {
+          method: 'GET',
+          url: '/uploads/image.png',
+        },
+      },
+      jest.fn()
+    );
+
+    expect(sendEvent).not.toHaveBeenCalled();
+  });
+
+  test.each(['OPTIONS', 'HEAD'])('Ignores %s method', async (method) => {
+    const sendEvent = jest.fn();
+
+    const middleware = createMiddleware({ sendEvent });
+
+    await middleware(
+      {
+        request: {
+          method,
+          url: '/some-api',
+        },
+      },
+      jest.fn()
+    );
+
+    expect(sendEvent).not.toHaveBeenCalled();
+  });
+
+  test('Stops sending after 1000 events', async () => {
+    const sendEvent = jest.fn();
+    const middleware = createMiddleware({ sendEvent });
+
+    for (let i = 0; i < 2000; i += 1) {
+      await middleware(
+        {
+          request: {
+            method: 'GET',
+            url: '/some-api',
+          },
+        },
+        jest.fn()
+      );
+    }
+
+    expect(sendEvent).toHaveBeenCalledTimes(1000);
+  });
+});

package/lib/services/metrics/__tests__/rate-limiter.test.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const wrapWithRateLimiter = require('../rate-limiter');
+
+describe('Telemetry daily RateLimiter', () => {
+  test('Passes event and payload to sender', async () => {
+    const sender = jest.fn(() => Promise.resolve(true));
+
+    const send = wrapWithRateLimiter(sender, { limitedEvents: ['testEvent'] });
+
+    const payload = { key: 'value' };
+    await send('notRestricted', payload);
+
+    expect(sender).toHaveBeenCalledWith('notRestricted', payload);
+  });
+
+  test('Calls sender if event is not restricted', async () => {
+    const sender = jest.fn(() => Promise.resolve(true));
+
+    const send = wrapWithRateLimiter(sender, { limitedEvents: ['testEvent'] });
+
+    await send('notRestricted');
+
+    expect(sender).toHaveBeenCalledWith('notRestricted');
+  });
+
+  test('Calls the sender as many times as request when events is not restricted', async () => {
+    const sender = jest.fn(() => Promise.resolve(true));
+
+    const send = wrapWithRateLimiter(sender, { limitedEvents: ['testEvent'] });
+
+    await send('notRestricted');
+    await send('notRestricted');
+    await send('notRestricted');
+
+    expect(sender).toHaveBeenCalledTimes(3);
+  });
+
+  test('Calls the sender only once when event is restricted', async () => {
+    const sender = jest.fn(() => Promise.resolve(true));
+
+    const send = wrapWithRateLimiter(sender, { limitedEvents: ['restrictedEvent'] });
+
+    await send('restrictedEvent');
+    await send('restrictedEvent');
+    await send('restrictedEvent');
+
+    expect(sender).toHaveBeenCalledTimes(1);
+  });
+});

package/lib/services/metrics/__tests__/stringify-deep.test.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const stringifyDeep = require('../stringify-deep');
+
+describe('stringifyDeep', () => {
+  test('Stringifies recursively', () => {
+    const input = {
+      property: 15,
+      subOjbect: {
+        property: 'test',
+        number: 81,
+        boolean: true,
+      },
+      arrayValue: ['valueA', 'valueB'],
+    };
+
+    expect(stringifyDeep(input)).toStrictEqual({
+      property: '15',
+      subOjbect: {
+        property: 'test',
+        number: '81',
+        boolean: 'true',
+      },
+      arrayValue: ['valueA', 'valueB'],
+    });
+  });
+});

package/lib/services/metrics/sender.js

@@ -4,7 +4,6 @@ const os = require('os');
 const path = require('path');
 const _ = require('lodash');
 const isDocker = require('is-docker');
-const fetch = require('node-fetch');
 const ciEnv = require('ci-info');
 const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
 const { env } = require('@strapi/utils');
@@ -82,7 +81,7 @@ module.exports = (strapi) => {
     };
 
     try {
-      const res = await fetch(`${ANALYTICS_URI}/api/v2/track`, reqParams);
+      const res = await strapi.fetch(`${ANALYTICS_URI}/api/v2/track`, reqParams);
       return res.ok;
     } catch (err) {
       return false;

package/lib/services/webhook-runner.js

@@ -6,7 +6,6 @@
 
 const debug = require('debug')('strapi:webhook');
 const _ = require('lodash');
-const fetch = require('node-fetch');
 
 const WorkerQueue = require('./worker-queue');
 
@@ -15,12 +14,13 @@ const defaultConfiguration = {
 };
 
 class WebhookRunner {
-  constructor({ eventHub, logger, configuration = {} }) {
-    debug('Initialized webhook runer');
+  constructor({ eventHub, logger, configuration = {}, fetch }) {
+    debug('Initialized webhook runner');
     this.eventHub = eventHub;
     this.logger = logger;
     this.webhooksMap = new Map();
     this.listeners = new Map();
+    this.fetch = fetch;
 
     if (typeof configuration !== 'object') {
       throw new Error(
@@ -76,7 +76,7 @@ class WebhookRunner {
   run(webhook, event, info = {}) {
     const { url, headers } = webhook;
 
-    return fetch(url, {
+    return this.fetch(url, {
       method: 'post',
       body: JSON.stringify({
         event,

package/lib/types/core/commands/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+
+export type AddCommandOptions = {
+  command: Command;
+  argv: Record<number, string>;
+};

package/lib/utils/__tests__/convert-custom-field-type.test.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const convertCustomFieldType = require('../convert-custom-field-type');
+
+describe('format attributes', () => {
+  it('replaces type customField with the underlying data type', () => {
+    global.strapi = {
+      container: {
+        // mock container.get('custom-fields')
+        get: jest.fn(() => ({
+          // mock container.get('custom-fields').get(uid)
+          get: jest.fn(() => ({
+            name: 'color',
+            plugin: 'mycustomfields',
+            type: 'text',
+          })),
+        })),
+      },
+      contentTypes: {
+        test: {
+          attributes: {
+            color: {
+              type: 'customField',
+              customField: 'plugin::mycustomfields.color',
+            },
+          },
+        },
+      },
+      components: {
+        'default.test': {
+          attributes: {
+            color: {
+              type: 'customField',
+              customField: 'plugin::mycustomfields.color',
+            },
+          },
+        },
+      },
+    };
+
+    convertCustomFieldType(global.strapi);
+
+    const expected = {
+      ...global.strapi,
+      contentTypes: {
+        test: {
+          attributes: {
+            color: {
+              type: 'text',
+              customField: 'plugin::mycustomfields.color',
+            },
+          },
+        },
+      },
+      components: {
+        'default.test': {
+          attributes: {
+            color: {
+              type: 'text',
+              customField: 'plugin::mycustomfields.color',
+            },
+          },
+        },
+      },
+    };
+
+    expect(global.strapi).toEqual(expected);
+  });
+});

package/lib/utils/__tests__/url-from-segments.test.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const getUrlFromSegments = require('../url-from-segments');
+
+describe('getUrlFromSegments', () => {
+  test('Handles hostname', () => {
+    expect(getUrlFromSegments({ hostname: 'localhost' })).toEqual('http://localhost');
+    expect(getUrlFromSegments({ hostname: 'otherhost.com' })).toEqual('http://otherhost.com');
+  });
+
+  test('Handles port', () => {
+    expect(getUrlFromSegments({ hostname: 'localhost', port: '80' })).toEqual('http://localhost');
+    expect(getUrlFromSegments({ hostname: 'localhost', port: '8000' })).toEqual(
+      'http://localhost:8000'
+    );
+    expect(getUrlFromSegments({ hostname: 'otherhost.com', port: 5421 })).toEqual(
+      'http://otherhost.com:5421'
+    );
+  });
+
+  test('Handles ssl and ports', () => {
+    expect(getUrlFromSegments({ hostname: 'localhost', ssl: true })).toEqual('https://localhost');
+
+    expect(getUrlFromSegments({ hostname: 'localhost', ssl: true, port: 532 })).toEqual(
+      'https://localhost:532'
+    );
+
+    expect(getUrlFromSegments({ hostname: 'localhost', ssl: true, port: 443 })).toEqual(
+      'https://localhost'
+    );
+
+    expect(getUrlFromSegments({ hostname: 'otherhost.com', ssl: true })).toEqual(
+      'https://otherhost.com'
+    );
+
+    expect(getUrlFromSegments({ hostname: 'otherhost.com', ssl: true, port: 7263 })).toEqual(
+      'https://otherhost.com:7263'
+    );
+  });
+});

package/lib/utils/fetch.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const nodeFetch = require('node-fetch');
+const HttpsProxyAgent = require('https-proxy-agent');
+
+function createStrapiFetch(strapi) {
+  function fetch(url, options) {
+    return nodeFetch(url, {
+      ...(fetch.agent ? { agent: fetch.agent } : {}),
+      ...options,
+    });
+  }
+
+  const { globalProxy: proxy } = strapi.config.get('server');
+
+  if (proxy) {
+    fetch.agent = new HttpsProxyAgent(proxy);
+  }
+
+  return fetch;
+}
+
+module.exports = createStrapiFetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.10.0-beta.1",
+  "version": "4.10.1-experimental.0",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -81,19 +81,19 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.10.0-beta.1",
-    "@strapi/data-transfer": "4.10.0-beta.1",
-    "@strapi/database": "4.10.0-beta.1",
-    "@strapi/generate-new": "4.10.0-beta.1",
-    "@strapi/generators": "4.10.0-beta.1",
-    "@strapi/logger": "4.10.0-beta.1",
-    "@strapi/permissions": "4.10.0-beta.1",
-    "@strapi/plugin-content-manager": "4.10.0-beta.1",
-    "@strapi/plugin-content-type-builder": "4.10.0-beta.1",
-    "@strapi/plugin-email": "4.10.0-beta.1",
-    "@strapi/plugin-upload": "4.10.0-beta.1",
-    "@strapi/typescript-utils": "4.10.0-beta.1",
-    "@strapi/utils": "4.10.0-beta.1",
+    "@strapi/admin": "4.10.1-experimental.0",
+    "@strapi/data-transfer": "4.10.1-experimental.0",
+    "@strapi/database": "4.10.1-experimental.0",
+    "@strapi/generate-new": "4.10.1-experimental.0",
+    "@strapi/generators": "4.10.1-experimental.0",
+    "@strapi/logger": "4.10.1-experimental.0",
+    "@strapi/permissions": "4.10.1-experimental.0",
+    "@strapi/plugin-content-manager": "4.10.1-experimental.0",
+    "@strapi/plugin-content-type-builder": "4.10.1-experimental.0",
+    "@strapi/plugin-email": "4.10.1-experimental.0",
+    "@strapi/plugin-upload": "4.10.1-experimental.0",
+    "@strapi/typescript-utils": "4.10.1-experimental.0",
+    "@strapi/utils": "4.10.1-experimental.0",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -109,6 +109,7 @@
     "fs-extra": "10.0.0",
     "glob": "7.2.0",
     "http-errors": "1.8.1",
+    "https-proxy-agent": "5.0.1",
     "inquirer": "8.2.5",
     "is-docker": "2.2.1",
     "koa": "2.13.4",
@@ -136,11 +137,11 @@
   },
   "devDependencies": {
     "supertest": "6.3.3",
-    "typescript": "4.6.2"
+    "typescript": "5.0.4"
   },
   "engines": {
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "95d581b31bee464af42e5d8db408fa578d8532c7"
+  "gitHead": "ce60415a0779e850da2c2edd80799f98918c000c"
 }