@orange-soft/strapi-deployment-trigger 1.0.0

package/server/src/controllers/controller.js

@@ -0,0 +1,95 @@
+const PLUGIN_ID = 'deployment-trigger';
+
+const getService = (strapi) => strapi.plugin(PLUGIN_ID).service('service');
+
+const controller = ({ strapi }) => ({
+  index(ctx) {
+    ctx.body = getService(strapi).getWelcomeMessage();
+  },
+
+  async getSettings(ctx) {
+    const settings = await getService(strapi).getSettings();
+    ctx.body = { data: settings };
+  },
+
+  async saveSettings(ctx) {
+    const { data } = ctx.request.body;
+    const settings = await getService(strapi).saveSettings(data);
+    ctx.body = { data: settings };
+  },
+
+  async getStatus(ctx) {
+    const service = getService(strapi);
+    const settings = await service.getSettings();
+    const configured = await service.isConfigured();
+    const hasToken = await service.hasToken();
+    const { owner, repo } = service.parseRepoUrl(settings.repoUrl);
+
+    ctx.body = {
+      data: {
+        configured,
+        hasToken,
+        settings,
+        parsed: { owner, repo }, // Include parsed values for display
+      },
+    };
+  },
+
+  async trigger(ctx) {
+    const service = getService(strapi);
+    const githubToken = await service.getToken();
+
+    if (!githubToken) {
+      return ctx.badRequest('GitHub token is not configured. Please add it in Settings.');
+    }
+
+    const settings = await service.getSettings();
+    const { owner, repo } = service.parseRepoUrl(settings.repoUrl);
+
+    if (!owner || !repo) {
+      return ctx.badRequest('GitHub repository URL is not configured or invalid. Please configure it in Settings.');
+    }
+
+    const { workflow = settings.workflow, branch = settings.branch } = ctx.request.body || {};
+
+    const url = `https://api.github.com/repos/${owner}/${repo}/actions/workflows/${workflow}/dispatches`;
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+          Authorization: `Bearer ${githubToken}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ ref: branch }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        strapi.log.error(`GitHub API error: ${response.status} - ${errorText}`);
+        return ctx.badRequest(`GitHub API error: ${response.status} - ${errorText}`);
+      }
+
+      strapi.log.info(`Deployment triggered for ${owner}/${repo} on branch ${branch}`);
+
+      const actionsUrl = `https://github.com/${owner}/${repo}/actions`;
+
+      ctx.body = {
+        data: {
+          success: true,
+          message: `Deployment triggered successfully for ${owner}/${repo}`,
+          repository: `${owner}/${repo}`,
+          workflow,
+          branch,
+          actionsUrl,
+        },
+      };
+    } catch (error) {
+      strapi.log.error('Error triggering deployment:', error);
+      return ctx.badRequest(`Failed to trigger deployment: ${error.message}`);
+    }
+  },
+});
+
+export default controller;

package/server/src/controllers/index.js

@@ -0,0 +1,5 @@
+import controller from './controller';
+
+export default {
+  controller,
+};

package/server/src/destroy.js

@@ -0,0 +1,5 @@
+const destroy = ({ strapi }) => {
+  // destroy phase
+};
+
+export default destroy;

package/server/src/index.js

@@ -0,0 +1,31 @@
+/**
+ * Application methods
+ */
+import bootstrap from './bootstrap';
+import destroy from './destroy';
+import register from './register';
+
+/**
+ * Plugin server methods
+ */
+import config from './config';
+import contentTypes from './content-types';
+import controllers from './controllers';
+import middlewares from './middlewares';
+import policies from './policies';
+import routes from './routes';
+import services from './services';
+
+export default {
+  bootstrap,
+  destroy,
+  register,
+
+  config,
+  controllers,
+  contentTypes,
+  middlewares,
+  policies,
+  routes,
+  services,
+};

package/server/src/middlewares/index.js

@@ -0,0 +1 @@
+export default {};

package/server/src/policies/index.js

@@ -0,0 +1 @@
+export default {};

package/server/src/register.js

@@ -0,0 +1,5 @@
+const register = ({ strapi }) => {
+  // register phase
+};
+
+export default register;

package/server/src/routes/admin/index.js

@@ -0,0 +1,37 @@
+export default () => ({
+  type: 'admin',
+  routes: [
+    {
+      method: 'GET',
+      path: '/settings',
+      handler: 'controller.getSettings',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'PUT',
+      path: '/settings',
+      handler: 'controller.saveSettings',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'GET',
+      path: '/status',
+      handler: 'controller.getStatus',
+      config: {
+        policies: [],
+      },
+    },
+    {
+      method: 'POST',
+      path: '/trigger',
+      handler: 'controller.trigger',
+      config: {
+        policies: [],
+      },
+    },
+  ],
+});

package/server/src/routes/content-api/index.js

@@ -0,0 +1,14 @@
+export default () => ({
+  type: 'content-api',
+  routes: [
+    {
+      method: 'GET',
+      path: '/',
+      // name of the controller file & the method.
+      handler: 'controller.index',
+      config: {
+        policies: [],
+      },
+    },
+  ],
+});

package/server/src/routes/index.js

@@ -0,0 +1,9 @@
+import contentAPIRoutes from './content-api';
+import adminAPIRoutes from './admin';
+
+const routes = {
+  'content-api': contentAPIRoutes,
+  admin: adminAPIRoutes,
+};
+
+export default routes;

package/server/src/services/index.js

@@ -0,0 +1,5 @@
+import service from './service';
+
+export default {
+  service,
+};

package/server/src/services/service.js

@@ -0,0 +1,124 @@
+const PLUGIN_ID = 'deployment-trigger';
+const STORE_KEY = 'settings';
+
+const DEFAULT_SETTINGS = {
+  repoUrl: '',
+  workflow: 'deploy.yml',
+  branch: 'master',
+};
+
+const service = ({ strapi }) => ({
+  getWelcomeMessage() {
+    return 'Welcome to Strapi Deployment Trigger';
+  },
+
+  maskToken(token) {
+    if (!token || token.length < 20) return null;
+    const head = token.slice(0, 15);
+    const tail = token.slice(-4);
+    return `${head}...${tail}`;
+  },
+
+  parseRepoUrl(repoUrl) {
+    if (!repoUrl) return { owner: null, repo: null };
+    try {
+      const url = new URL(repoUrl);
+      const parts = url.pathname.split('/').filter(Boolean);
+      if (parts.length >= 2) {
+        return { owner: parts[0], repo: parts[1] };
+      }
+    } catch (e) {
+      // Invalid URL
+    }
+    return { owner: null, repo: null };
+  },
+
+  async getSettings() {
+    // 1. Try database (core store)
+    const store = strapi.store({ type: 'plugin', name: PLUGIN_ID });
+    const dbSettings = await store.get({ key: STORE_KEY });
+    const envToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+
+    if (dbSettings && dbSettings.repoUrl) {
+      const token = dbSettings.githubToken || envToken;
+      return {
+        ...dbSettings,
+        githubToken: undefined, // Never expose full token
+        hasToken: !!token,
+        maskedToken: this.maskToken(token),
+      };
+    }
+
+    // 2. Fallback to plugin config (convert old format if needed)
+    const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID}`) || {};
+    if (pluginConfig.githubOwner && pluginConfig.githubRepo) {
+      return {
+        repoUrl: `https://github.com/${pluginConfig.githubOwner}/${pluginConfig.githubRepo}`,
+        workflow: pluginConfig.workflow || DEFAULT_SETTINGS.workflow,
+        branch: pluginConfig.branch || DEFAULT_SETTINGS.branch,
+        hasToken: !!envToken,
+        maskedToken: this.maskToken(envToken),
+      };
+    }
+
+    // 3. Return defaults merged with any partial DB settings
+    const token = dbSettings?.githubToken || envToken;
+    return {
+      ...DEFAULT_SETTINGS,
+      ...dbSettings,
+      githubToken: undefined,
+      hasToken: !!token,
+      maskedToken: this.maskToken(token),
+    };
+  },
+
+  async saveSettings(settings) {
+    const store = strapi.store({ type: 'plugin', name: PLUGIN_ID });
+
+    // Get existing settings to preserve token if not provided
+    const existingSettings = await store.get({ key: STORE_KEY }) || {};
+
+    const settingsToSave = {
+      repoUrl: settings.repoUrl,
+      workflow: settings.workflow || DEFAULT_SETTINGS.workflow,
+      branch: settings.branch || DEFAULT_SETTINGS.branch,
+      // Only update token if a new one is provided
+      githubToken: settings.githubToken || existingSettings.githubToken,
+    };
+
+    await store.set({ key: STORE_KEY, value: settingsToSave });
+
+    // Return without exposing token
+    return {
+      ...settingsToSave,
+      githubToken: undefined,
+      hasToken: !!settingsToSave.githubToken || !!process.env.GITHUB_PERSONAL_ACCESS_TOKEN,
+    };
+  },
+
+  async getToken() {
+    // Priority: DB token > Environment variable
+    const store = strapi.store({ type: 'plugin', name: PLUGIN_ID });
+    const dbSettings = await store.get({ key: STORE_KEY });
+
+    if (dbSettings?.githubToken) {
+      return dbSettings.githubToken;
+    }
+
+    return process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+  },
+
+  async isConfigured() {
+    const settings = await this.getSettings();
+    const hasToken = await this.getToken();
+    const { owner, repo } = this.parseRepoUrl(settings.repoUrl);
+    return !!(owner && repo && hasToken);
+  },
+
+  async hasToken() {
+    const token = await this.getToken();
+    return !!token;
+  },
+});
+
+export default service;