@cloudimage-strapi/content-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 scaleflex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# Cloudimage plugin from Scaleflex for Strapi v4
+
+## Install
+
+`npm install @cloudimage-strapi/content-plugin`
+
+## Config
+
+
+`config/middlewares.js`
+
+Replace `'strapi::security',` with:
+
+```
+{
+  name: 'strapi::security',
+  config: {
+    contentSecurityPolicy: {
+      useDefaults: true,
+      directives: {
+        'connect-src': ["'self'", 'https:'],
+        'img-src': ["'self'", 'data:', 'blob:', 'scaleflex.cloudimg.io', 'assets.scaleflex.com', '*.cloudimg.io'],
+        'media-src': ["'self'", 'data:', 'blob:', 'scaleflex.cloudimg.io', 'assets.scaleflex.com', '*.cloudimg.io'],
+        upgradeInsecureRequests: null,
+      },
+    },
+  },
+},
+```
+
+`config/server.js`
+
+Append `url: 'domain (including the http/https:// part)'`
+
+Eg: if you website is called `mywebsite.com`, then write like this:
+
+```
+module.exports = ({ env }) => ({
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 1337),
+  app: {
+    keys: env.array('APP_KEYS'),
+  },
+  url: 'https://www.mywebsite.com',
+});
+```
+
+**It’s very important that you don’t forget to do this**
+
+## Configure
+
+![](https://user-images.githubusercontent.com/20809372/210363042-d254b19b-2cb6-493c-b3fe-676131d15cf3.png)
+
+- You can enter either token or domain.
+- Whether your Cloudimage token is v7 or not, it will be auto-detected and set.
+
+If you enter nothing or an invalid token, you will get this error.
+
+![](https://user-images.githubusercontent.com/20809372/210363124-a3c548f5-8bf3-4303-bad7-22906f5e1585.png)
+
+In the rare case that we can’t auto-detect whether token is v7 or not, you will get the option to manually set it.
+
+![](https://user-images.githubusercontent.com/20809372/210363178-0bb4c4b7-6fe6-4bee-8226-61fe0128c92f.png)
+
+## What the plugin brings
+
+1. This plugin simple gives client an interface to save the configuration settings.
+2. It also allows clients to Cloudimage-ize all previous images:
+
+![](https://user-images.githubusercontent.com/20809372/210363230-37094499-ecea-4f14-92e3-0a7217bb9a18.png)
+
+- It will NOT Cloudimage-ize images that are already hosted on Filerobot.
+- It will only sync images, no videos nor audios.

package/admin/src/components/Initializer/index.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * Initializer
+ *
+ */
+
+import { useEffect, useRef } from 'react';
+import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef();
+  ref.current = setPlugin;
+
+  useEffect(() => {
+    ref.current(pluginId);
+  }, []);
+
+  return null;
+};
+
+Initializer.propTypes = {
+  setPlugin: PropTypes.func.isRequired,
+};
+
+export default Initializer;

package/admin/src/components/PluginIcon/index.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * PluginIcon
+ *
+ */
+
+import React from 'react';
+import Puzzle from '@strapi/icons/Puzzle';
+
+const PluginIcon = () => <img src="https://assets.scaleflex.com/Marketing/Logos/Cloudimage+Logos/Favicon/CLOUDIMAGE+favicon.ico" width="16" height="16" />;
+
+export default PluginIcon;

package/admin/src/index.js

@@ -0,0 +1,63 @@
+import { prefixPluginTranslations } from '@strapi/helper-plugin';
+import pluginPkg from '../../package.json';
+import pluginId from './pluginId';
+import Initializer from './components/Initializer';
+import PluginIcon from './components/PluginIcon';
+
+const name = "scaleflex-cloudimage";
+
+export default {
+  register(app) {
+    app.addMenuLink({
+      to: `/plugins/${pluginId}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${pluginId}.plugin.name`,
+        defaultMessage: 'Cloudimage by Scaleflex',
+      },
+      Component: async () => {
+        const component = await import(/* webpackChunkName: "[request]" */ './pages/App');
+
+        return component;
+      },
+      permissions: [
+        // Uncomment to set the permissions of the plugin here
+        // {
+        //   action: '', // the action name should be plugin::plugin-name.actionType
+        //   subject: null,
+        // },
+      ],
+    });
+    app.registerPlugin({
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      name,
+    });
+  },
+
+  bootstrap(app) {},
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map(locale => {
+        return import(
+          /* webpackChunkName: "translation-[request]" */ `./translations/${locale}.json`
+        )
+          .then(({ default: data }) => {
+            return {
+              data: prefixPluginTranslations(data, pluginId),
+              locale,
+            };
+          })
+          .catch(() => {
+            return {
+              data: {},
+              locale,
+            };
+          });
+      })
+    );
+
+    return Promise.resolve(importedTrads);
+  },
+};

package/admin/src/pages/App/index.js

@@ -0,0 +1,25 @@
+/**
+ *
+ * This component is the skeleton around the actual pages, and should only
+ * contain code that should be seen on all pages. (e.g. navigation bar)
+ *
+ */
+
+import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+import { NotFound } from '@strapi/helper-plugin';
+import pluginId from '../../pluginId';
+import HomePage from '../HomePage';
+
+const App = () => {
+  return (
+    <div>
+      <Switch>
+        <Route path={`/plugins/${pluginId}`} component={HomePage} exact />
+        <Route component={NotFound} />
+      </Switch>
+    </div>
+  );
+};
+
+export default App;

package/admin/src/pages/HomePage/index.js

@@ -0,0 +1,199 @@
+/*
+ *
+ * HomePage
+ *
+ */
+
+import React, {memo, useState, useEffect} from 'react';
+import { Stack, Box, Typography, Field, FieldLabel, FieldInput, Button, Alert, Radio, RadioGroup } from '@strapi/design-system';
+import {request} from "@strapi/helper-plugin";
+import pluginId from '../../pluginId';
+
+const HomePage = () => {
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [domain, setDomain] = useState('');
+  const [isV7, setIsV7] = useState(false);
+  const [isV7CheckSuccessful, setIsV7CheckSuccessful] = useState(true);
+  const [manualV7, setManualV7] = useState(false);
+  const [disabledAllButtons, setDisabledAllButtons] = useState(false);
+  const [success, setSuccess] = useState(false);
+  const [error, setError] = useState(false);
+  const [disableUpdateButtons, setDisableUpdateButtons] = useState(false);
+  const [updateCount, setUpdateCount] = useState(-1);
+  const [displayUpdateResult, setDisplayUpdateResult] = useState(false);
+  const [updateMessage, setUpdateMessage] = useState('');
+
+  useEffect(() => {
+    request(`/${pluginId}/config`, {method: 'GET'}).then(config => {
+      setConfig(config);
+      setDomain(config.domain);
+      setLoading(false);
+
+      if (!config.domain || !config.hasOwnProperty('isV7'))
+      {
+        setDisableUpdateButtons(true);
+      }
+      else
+      {
+        setDisableUpdateButtons(false);
+      }
+    });
+  }, []);
+
+  if (loading)
+  {
+    return (
+      <Typography>fetching configuration...</Typography>
+    );
+  }
+
+  const saveConfiguration = async () => {
+    if (!domain)
+    {
+      setError(true);
+      setSuccess(false);
+      setDisabledAllButtons(false);
+
+      return;
+    }
+    else
+    {
+      setError(false);
+    }
+
+    setDisabledAllButtons(true);
+
+    // Check whether input is token or domain
+    let tokenOrDomain = '';
+
+    if (domain && domain.indexOf('.') === -1) 
+    {
+      tokenOrDomain = `${domain}.cloudimg.io`.trim();
+    } 
+    else 
+    {
+      tokenOrDomain = domain.trim();
+    }
+
+    // Check whether v7 or not
+    let v7Check = await request(`/${pluginId}/is-v7?domain=${tokenOrDomain}`, {method: 'GET'});
+
+    if (!v7Check.domainExists)
+    {
+      setError(true);
+      setSuccess(false);
+      setDisabledAllButtons(false);
+
+      return;
+    }
+    else
+    {
+      setError(false);
+    }
+
+    setIsV7CheckSuccessful(v7Check.isSuccess);
+
+    let isV7Overall = v7Check.isSuccess ? v7Check.isV7 : manualV7;
+    setIsV7(isV7Overall);
+
+    // POST to backend to set config
+    let config = {
+      domain: tokenOrDomain,
+      isV7: isV7Overall
+    }
+
+    let updatedConfigs = await request(`/${pluginId}/update-config`, {method: 'PUT', body: config});
+    
+    setDomain(updatedConfigs.domain);
+    setSuccess(true);
+    setDisabledAllButtons(false);
+  }
+
+  const countUpdate = async () => {
+    setUpdateCount(-1);
+    setDisabledAllButtons(true);
+    let count = await request(`/${pluginId}/count-update`, {method: 'GET'});
+    setUpdateCount(count);
+    setDisabledAllButtons(false);
+  }
+  const updateMedia = async () => {
+    setDisplayUpdateResult(false);
+    setDisabledAllButtons(true);
+
+    let result = await request(`/${pluginId}/update-media`, {method: 'PUT'});
+
+    if (result.response === false)
+    {
+      setUpdateMessage('Update was not successful. Please try again later.');
+    }
+    else
+    {
+      setUpdateMessage(`${result.response} updates was successful.`);
+    }
+    
+    setDisplayUpdateResult(true);
+    setDisabledAllButtons(false);
+  }
+
+  return (
+    <>
+      <Stack spacing={4} padding={3}>
+        {success && isV7CheckSuccessful && (
+          <Alert title="Successful" onClose={() => setSuccess(false)} closeLabel="Close alert" variant={'success'}>
+            Configuration updated. Your domain is {isV7 ? '' : 'not'} of Cloudimage version 7.
+          </Alert>
+        )}
+        {success && !isV7CheckSuccessful && (
+          <Alert title="Failed" onClose={() => setError(false)} closeLabel="Close alert" variant={'danger'}>
+            Cannot auto-determine whether it's Cloudimage version 7 or not. Please mannually set Cloudimage version.
+          </Alert>
+        )}
+        {error && (
+          <Alert title="Failed" onClose={() => setError(false)} closeLabel="Close alert" variant={'danger'}>
+            Please check your configuration inputs. Ensure you entered valid inputs for all required fields.
+          </Alert>
+        )}
+        {updateCount > -1 && (
+          <Alert onClose={() => setUpdateCount(-1)} closeLabel="Close alert" variant={'success'}>
+            There are {updateCount} image URLs to be updated.
+          </Alert>
+        )}
+        {displayUpdateResult && (
+          <Alert onClose={() => setDisplayUpdateResult(false)} closeLabel="Close alert" variant={'success'}>
+            {(updateCount <= 0) ? 'None are to be updated.' : updateMessage}
+          </Alert>
+        )}
+        <Box paddingLeft={8} paddingTop={5} paddingRight={8}>
+          <Typography variant={'alpha'}>Cloudimage by Scaleflex</Typography>
+        </Box>
+        <Field name="domain">
+          <Stack spacing={1}>
+            <FieldLabel>Token or Domain *</FieldLabel>
+            <FieldInput type="text" placeholder="Token/Domain" value={domain} onChange={(e) => {
+              setDomain(e.target.value)
+            }}/>
+          </Stack>
+        </Field>
+        {!isV7CheckSuccessful && (
+          <Stack spacing={1}>
+            <FieldLabel>Is Cloudimage version 7 ?</FieldLabel>
+            <RadioGroup onChange={e => setManualV7(e.target.value)} value={manualV7} name="manualV7">
+              <Radio value="true">Version 7</Radio>
+              <Radio value="false">Not version 7</Radio>
+            </RadioGroup>
+          </Stack>
+        )}
+        <Box width={200}>
+          <Button disabled={disabledAllButtons} onClick={() => saveConfiguration()}>Save configuration</Button>
+        </Box>
+        <Stack horizontal spacing={4}>
+          <Button disabled={disabledAllButtons || disableUpdateButtons} onClick={() => countUpdate()}>Count updatable images</Button>
+          <Button disabled={disabledAllButtons || disableUpdateButtons} onClick={() => updateMedia()}>Update old images</Button>
+        </Stack>
+      </Stack>
+    </>
+  )
+};
+
+export default memo(HomePage);

package/admin/src/pluginId.js

@@ -0,0 +1,5 @@
+import pluginPkg from '../../package.json';
+
+const pluginId = "scaleflex-cloudimage".replace(/^(@[^-,.][\w,-]+\/|strapi-)plugin-/i, '');
+
+export default pluginId;

package/admin/src/translations/en.json

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

package/admin/src/translations/fr.json

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

package/admin/src/utils/axiosInstance.js

@@ -0,0 +1,40 @@
+/**
+ * axios with a custom config.
+ */
+
+import axios from 'axios';
+import { auth } from '@strapi/helper-plugin';
+
+const instance = axios.create({
+  baseURL: process.env.STRAPI_ADMIN_BACKEND_URL,
+});
+
+instance.interceptors.request.use(
+  async config => {
+    config.headers = {
+      Authorization: `Bearer ${auth.getToken()}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+
+    return config;
+  },
+  error => {
+    Promise.reject(error);
+  }
+);
+
+instance.interceptors.response.use(
+  response => response,
+  error => {
+    // whatever you want to do with the error
+    if (error.response?.status === 401) {
+      auth.clearAppStorage();
+      window.location.reload();
+    }
+
+    throw error;
+  }
+);
+
+export default instance;

package/admin/src/utils/getTrad.js

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = id => `${pluginId}.${id}`;
+
+export default getTrad;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@cloudimage-strapi/content-plugin",
+  "version": "1.0.0",
+  "description": "Strapi v4 plugin for Filerobot by Scaleflex",
+  "strapi": {
+    "name": "scaleflex-cloudimage",
+    "description": "Scaleflex Cloudimage",
+    "kind": "plugin",
+    "displayName": "Scaleflex Cloudimage"
+  },
+  "dependencies": {
+    "@strapi/design-system": "^1.4.1"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^4.3.0"
+  },
+  "author": {
+    "name": "Scaleflex"
+  },
+  "maintainers": [
+    {
+      "name": "Ruslan Aliyev"
+    }
+  ],
+  "engines": {
+    "node": ">=12.x. <=16.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "scaleflex",
+    "filerobot",
+    "strapi"
+  ]
+}

package/server/bootstrap.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // bootstrap phase
+};

package/server/config/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  default: {},
+  validator() {},
+};

package/server/content-types/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/server/controllers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const scaleflexCloudimage = require('./scaleflex-cloudimage');
+
+module.exports = {
+  scaleflexCloudimage,
+};

package/server/controllers/scaleflex-cloudimage.js

@@ -0,0 +1,40 @@
+'use strict';
+
+module.exports = ({ strapi }) => ({
+  async index(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .getWelcomeMessage();
+  },
+  async getConfig(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .getConfig();
+  },
+  async updateConfig(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .updateConfig(ctx);
+  },
+  async checkV7(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .checkV7(ctx);
+  },
+  async countUpdate(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .countUpdate(ctx);
+  },
+  async updateMedia(ctx) {
+    ctx.body = await strapi
+      .plugin('scaleflex-cloudimage')
+      .service('scaleflexCloudimage')
+      .updateMedia(ctx);
+  },
+});

package/server/destroy.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // destroy phase
+};

package/server/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const contentTypes = require('./content-types');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const middlewares = require('./middlewares');
+const policies = require('./policies');
+const services = require('./services');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares,
+};

package/server/middlewares/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/server/policies/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/server/register.js

@@ -0,0 +1,65 @@
+'use strict';
+//@Todo: Think about how this can be done in a cluster of may servers. Maybe persist the plugin's middleware settings in DB, then load it into that memory object upon start
+module.exports = ({ strapi }) => {
+//   const pluginMiddleware = {
+//     name: 'strapi::security',
+//     config: {
+//       contentSecurityPolicy: {
+//         useDefaults: true,
+//         directives: {
+//           'connect-src': ["'self'", 'https:'],
+//           'img-src': ["'self'", 'data:', 'blob:', 'scaleflex.cloudimg.io', 'assets.scaleflex.com', '*.cloudimg.io'],
+//           'media-src': ["'self'", 'data:', 'blob:', 'scaleflex.cloudimg.io', 'assets.scaleflex.com', '*.cloudimg.io'],
+//           upgradeInsecureRequests: null,
+//         },
+//       },
+//     },
+//   };
+
+//   // Merge a `source` object to a `target` recursively
+//   const merge = (target, source) => {
+//     // Iterate through `source` properties and if an `Object` set property to merge of `target` and `source` properties
+//     for (const key of Object.keys(source))
+//     {
+//       if (Array.isArray(source[key]))
+//       {
+//         Object.assign(source[key], [...new Set(target[key].concat(source[key]))]);
+//       }
+
+//       if (source[key] instanceof Object && !Array.isArray(source[key]))
+//       {
+//         Object.assign(source[key], merge(target[key], source[key]));
+//       }
+//     }
+
+//     // Join `target` and modified `source`
+//     Object.assign(target || {}, source);
+
+//     return target;
+//   };
+
+//   for (let index = 1; index < strapi.config.middlewares.length; index++)
+//   {
+//     let item = strapi.config.middlewares[index];
+
+//     if (typeof item === 'object' && item.name === 'strapi::security')
+//     {
+//       let mergedSettings = merge(item.config, pluginMiddleware.config);
+//       strapi.config.middlewares.splice(index, 1, {name: 'strapi::security', config: mergedSettings});
+
+//       break;
+//     }
+//     else if (typeof item === 'string' && item === 'strapi::security')
+//     {
+//       strapi.config.middlewares.splice(index, 1, pluginMiddleware);
+
+//       break;
+//     }
+//     else
+//     {
+//       strapi.config.middlewares.push(pluginMiddleware);
+
+//       break;
+//     }
+//   }
+};

package/server/routes/index.js

@@ -0,0 +1,56 @@
+module.exports = [
+  {
+    method: 'GET',
+    path: '/',
+    handler: 'scaleflexCloudimage.index',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+  {
+    method: 'GET',
+    path: '/config',
+    handler: 'scaleflexCloudimage.getConfig',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/update-config',
+    handler: 'scaleflexCloudimage.updateConfig',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+  {
+    method: 'GET',
+    path: '/is-v7',
+    handler: 'scaleflexCloudimage.checkV7',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+  {
+    method: 'GET',
+    path: '/count-update',
+    handler: 'scaleflexCloudimage.countUpdate',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/update-media',
+    handler: 'scaleflexCloudimage.updateMedia',
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+];

package/server/services/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const scaleflexCloudimage = require('./scaleflex-cloudimage');
+
+module.exports = {
+  scaleflexCloudimage,
+};

package/server/services/scaleflex-cloudimage.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const fetch = require("node-fetch");
+
+module.exports = ({ strapi }) => ({
+  getWelcomeMessage() {
+    return 'Thank you for using Scaleflex Filerobot';
+  },
+  getPluginStore() {
+    return strapi.store({
+      environment: strapi.config.environment,
+      type: 'plugin',
+      name: 'cloudimage',
+    });
+  },
+  async getConfig() {
+    const pluginStore = this.getPluginStore();
+
+    let config = {
+      domain: '',
+      isV7: ''
+    }
+
+    const storedConfig = await pluginStore.get({key: 'options'})
+    if (storedConfig) {
+      config = storedConfig;
+    }
+
+    return config
+  },
+  async updateConfig(ctx) {
+    const pluginStore = this.getPluginStore();
+
+    await pluginStore.set({
+      key: 'options',
+      value: ctx.request.body
+    });
+
+    const config = await pluginStore.get({key: 'options'});
+
+    // if (config.domain)
+    // {
+    //   for (let index = 1; index < strapi.config.middlewares.length; index++)
+    //   {
+    //     let item = strapi.config.middlewares[index];
+
+    //     if (typeof item === 'object' && item.name === 'strapi::security' 
+    //       && !item.config.contentSecurityPolicy.directives['img-src'].includes(config.domain))
+    //     {
+    //       strapi.config.middlewares[index].config.contentSecurityPolicy.directives['img-src'].push(config.domain);
+    //       strapi.config.middlewares[index].config.contentSecurityPolicy.directives['media-src'].push(config.domain);
+    //     }
+    //   }
+    // }
+
+    return config;
+  },
+  async checkV7(ctx) {
+    let domain = ctx.request.query.domain;
+
+    let response = {};
+    let responseV7 = {};
+
+    try 
+    {
+      response = await fetch(`https://${domain}/http://sample.li/blank.png`);
+      responseV7 = await fetch(`https://${domain}/v7/http://sample.li/blank.png`);
+    } 
+    catch (error) 
+    {
+      console.error(error);
+
+      return {domainExists: false};
+    }
+
+    let isValid = response.status === 200 && !response.headers.get('x-hexa-missingbehavior');
+    let isV7Valid = responseV7.status === 200 && !responseV7.headers.get('x-hexa-missingbehavior');
+
+    if (isValid && !isV7Valid)
+    {
+      return {isSuccess: true, domainExists: true, isV7: false};
+    }
+    else if (!isValid && isV7Valid)
+    {
+      return {isSuccess: true, domainExists: true, isV7: true};
+    }
+    else
+    {
+      return {isSuccess: false, domainExists: true};
+    }
+  },
+  async countUpdate(ctx) {
+    let pluginStore = this.getPluginStore();
+    let pluginConfig = await pluginStore.get({key: 'options'});
+    let domain = pluginConfig.domain;
+
+    let media = await strapi.entityService.findMany('plugin::upload.file', {
+      populate: {category: true},
+      filters: { // https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/entity-service/filter.html#and
+        $and: [
+          {
+            url: { $notContains: domain, },
+          },
+          {
+            mime: { $contains: 'image', },
+          },
+          {
+            provider: { $notContains: 'filerobot', },
+          },
+        ],
+      },
+    });
+
+    return media.length;
+  },
+  async updateMedia(ctx) {
+    let baseUrl = strapi.config.get('server.url');
+    let pluginStore = this.getPluginStore();
+    let pluginConfig = await pluginStore.get({key: 'options'});
+    let domain = pluginConfig.domain;
+    let isV7 = pluginConfig.isV7;
+
+    let media = await strapi.entityService.findMany('plugin::upload.file', {
+      populate: {category: true},
+      filters: {
+        $and: [
+          {
+            url: { $notContains: domain, },
+          },
+          {
+            mime: { $contains: 'image', },
+          },
+          {
+            provider: { $notContains: 'filerobot', },
+          },
+        ],
+      },
+    });
+
+    return Promise.all(media.map((item, index) => {
+      let prepUrl = '';
+
+      if (/^https?:\/\//.test(item.url))
+      {
+        prepUrl = item.url.replace(/^https?:\/\//, '');
+      }
+      else
+      {
+        prepUrl = `${baseUrl}${item.url}`.replace(/^https?:\/\//, '');
+      }
+
+      let ciUrl = `https://${pluginConfig.domain}${pluginConfig.isV7 ? '/v7' : ''}/${prepUrl}`;
+
+      return strapi.entityService.update('plugin::upload.file', item.id, {
+        data: { 
+          url: ciUrl, 
+          formats: null 
+        },
+      })
+      .then(function(result) {
+        return {success: true, result: result};
+      })
+      .catch(function(error) {
+        return {success: false, error: error.message};
+      });
+    }))
+    .then(function(results) {
+      let successCount = 0;
+
+      results.forEach((result, index) => {
+        if (result.success)
+        {
+          successCount++;
+        }
+      });
+
+      return {response: `${successCount} / ${results.length}`};
+    })
+    .catch(function(error) {
+      console.dir(error.message);
+
+      return {response: false};
+    });
+  },
+});

package/strapi-admin.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./admin/src').default;

package/strapi-server.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./server');