@geekron/strapi 0.1.2 → 0.1.4

package/dist/server/index.js

@@ -33,55 +33,858 @@ __export(exports_src, {
   default: () => src_default
 });
 module.exports = __toCommonJS(exports_src);
+// server/src/api/common/content-types/common/schema.json
+var schema_default = {
+  kind: "singleType",
+  collectionName: "commons",
+  info: {
+    singularName: "common",
+    pluralName: "commons",
+    displayName: "Common",
+    description: "Define common settings"
+  },
+  options: {
+    draftAndPublish: true
+  },
+  pluginOptions: {
+    i18n: {
+      localized: true
+    }
+  },
+  attributes: {
+    favicon: {
+      type: "media",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      multiple: false,
+      required: false,
+      allowedTypes: [
+        "images",
+        "files",
+        "videos"
+      ]
+    },
+    title: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      required: true
+    },
+    description: {
+      type: "text",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      required: false
+    },
+    copyright: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      default: "Copyright"
+    },
+    icp: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    }
+  }
+};
+
+// server/src/api/common/controllers/common.ts
+var import_strapi = require("@strapi/strapi");
+var common_default = import_strapi.factories.createCoreController("plugin::website.common");
+
+// server/src/api/common/routes/common.ts
+var import_strapi2 = require("@strapi/strapi");
+var common_default2 = import_strapi2.factories.createCoreRouter("plugin::website.common");
+
+// server/src/api/common/services/common.ts
+var import_strapi3 = require("@strapi/strapi");
+var common_default3 = import_strapi3.factories.createCoreService("plugin::website.common");
+
+// server/src/api/common/index.ts
+var common_default4 = {
+  schema: schema_default,
+  controllers: common_default,
+  services: common_default3,
+  routes: common_default2
+};
+// server/src/api/menu/content-types/menu/schema.json
+var schema_default2 = {
+  kind: "singleType",
+  collectionName: "menus",
+  info: {
+    singularName: "menu",
+    pluralName: "menus",
+    displayName: "Menu"
+  },
+  options: {
+    draftAndPublish: true
+  },
+  pluginOptions: {
+    i18n: {
+      localized: true
+    }
+  },
+  attributes: {
+    title: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      required: true
+    }
+  }
+};
+
+// server/src/api/menu/controllers/menu.ts
+var import_strapi4 = require("@strapi/strapi");
+var menu_default = import_strapi4.factories.createCoreController("plugin::website.menu");
+
+// server/src/api/menu/routes/menu.ts
+var import_strapi5 = require("@strapi/strapi");
+var menu_default2 = import_strapi5.factories.createCoreRouter("plugin::website.menu");
+
+// server/src/api/menu/services/menu.ts
+var import_strapi6 = require("@strapi/strapi");
+var menu_default3 = import_strapi6.factories.createCoreService("plugin::website.menu");
+
+// server/src/api/menu/index.ts
+var menu_default4 = {
+  schema: schema_default2,
+  controllers: menu_default,
+  services: menu_default3,
+  routes: menu_default2
+};
+// server/src/api/site/content-types/site/schema.json
+var schema_default3 = {
+  kind: "singleType",
+  collectionName: "sites",
+  info: {
+    singularName: "site",
+    pluralName: "sites",
+    displayName: "Site"
+  },
+  options: {
+    draftAndPublish: true
+  },
+  pluginOptions: {
+    i18n: {
+      localized: true
+    }
+  },
+  attributes: {
+    enabled: {
+      type: "boolean",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      required: true,
+      default: true
+    },
+    title: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    logo: {
+      type: "media",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      multiple: false,
+      allowedTypes: [
+        "images"
+      ]
+    },
+    icon: {
+      type: "media",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      multiple: false,
+      allowedTypes: [
+        "images"
+      ]
+    },
+    url: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    robots: {
+      type: "text",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    head: {
+      type: "text",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    foot: {
+      type: "text",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    inquiryEmail: {
+      type: "email",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      }
+    },
+    index: {
+      type: "boolean",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      default: false
+    }
+  }
+};
+
+// server/src/api/site/controllers/site.ts
+var import_strapi7 = require("@strapi/strapi");
+var site_default = import_strapi7.factories.createCoreController("plugin::website.site");
+
+// server/src/api/site/routes/site.ts
+var import_strapi8 = require("@strapi/strapi");
+var site_default2 = import_strapi8.factories.createCoreRouter("plugin::website.site");
+
+// server/src/api/site/services/site.ts
+var import_strapi9 = require("@strapi/strapi");
+var site_default3 = import_strapi9.factories.createCoreService("plugin::website.site");
+
+// server/src/api/site/index.ts
+var site_default4 = {
+  schema: schema_default3,
+  controllers: site_default,
+  services: site_default3,
+  routes: site_default2
+};
+// server/src/api/translation/content-types/translation/schema.json
+var schema_default4 = {
+  kind: "collectionType",
+  collectionName: "translations",
+  info: {
+    singularName: "translation",
+    pluralName: "translations",
+    displayName: "Translation"
+  },
+  options: {
+    draftAndPublish: true
+  },
+  pluginOptions: {
+    i18n: {
+      localized: true
+    }
+  },
+  attributes: {
+    key: {
+      type: "string",
+      pluginOptions: {
+        i18n: {
+          localized: false
+        }
+      },
+      required: true,
+      unique: true
+    },
+    value: {
+      type: "text",
+      pluginOptions: {
+        i18n: {
+          localized: true
+        }
+      },
+      required: true
+    }
+  }
+};
+
+// server/src/api/translation/controllers/translation.ts
+var import_strapi10 = require("@strapi/strapi");
+var translation_default = import_strapi10.factories.createCoreController("plugin::website.translation");
+
+// server/src/api/translation/routes/translation.ts
+var import_strapi11 = require("@strapi/strapi");
+var translation_default2 = import_strapi11.factories.createCoreRouter("plugin::website.translation");
+
+// server/src/api/translation/services/translation.ts
+var import_strapi12 = require("@strapi/strapi");
+var translation_default3 = import_strapi12.factories.createCoreService("plugin::website.translation");
+
+// server/src/api/translation/index.ts
+var translation_default4 = {
+  schema: schema_default4,
+  controllers: translation_default,
+  services: translation_default3,
+  routes: translation_default2
+};
+
+// server/src/api/index.ts
+var contentTypes = {};
+var controllers = {};
+var routes = {};
+var services = {};
+contentTypes.common = {
+  schema: common_default4.schema
+};
+contentTypes.menu = {
+  schema: menu_default4.schema
+};
+contentTypes.site = {
+  schema: site_default4.schema
+};
+contentTypes.translation = {
+  schema: translation_default4.schema
+};
+routes.common = common_default4.routes;
+routes.menu = menu_default4.routes;
+routes.site = site_default4.routes;
+routes.translation = translation_default4.routes;
+services.common = common_default4.services;
+services.menu = menu_default4.services;
+services.site = site_default4.services;
+services.translation = translation_default4.services;
+controllers.common = common_default4.controllers;
+controllers.menu = menu_default4.controllers;
+controllers.site = site_default4.controllers;
+controllers.translation = translation_default4.controllers;
+var api_default = {
+  contentTypes,
+  controllers,
+  routes,
+  services
+};
 
 // server/src/bootstrap.ts
-var bootstrap = ({ strapi }) => {
-  strapi.log.info("dashboard server plugin: bootstrap");
+var bootstrap = ({ strapi: strapi2 }) => {
+  strapi2.log.info("website server plugin: bootstrap");
 };
 var bootstrap_default = bootstrap;
 
+// server/src/config/index.ts
+var config = {
+  default: {},
+  validator: (config2) => config2
+};
+var config_default = config;
+
 // server/src/contentTypes/index.ts
-var contentTypes = {};
-var contentTypes_default = contentTypes;
+var contentTypes2 = {};
+var contentTypes_default = contentTypes2;
+
+// server/src/controllers/fields.ts
+var checkAvailable = async (context) => {
+  const body = context.request.body;
+  if (body.kind === "collectionType") {
+    const entities = await strapi.entityService.findMany(body.uid, {
+      filters: {
+        [body.field]: {
+          $eq: body.value
+        }
+      }
+    });
+    return { isAvailable: !entities?.length };
+  }
+  return { isAvailable: true };
+};
+var fields = {
+  checkAvailable
+};
+var fields_default = fields;
+
+// server/src/controllers/utils/request.ts
+var getWebsiteConfig = async () => {
+  const locale = await strapi.plugin("i18n").service("locales").getDefaultLocale();
+  const [site, [token]] = await Promise.all([
+    strapi.db.query("plugin::website.site").findOne({ where: { locale } }),
+    strapi.db.query("admin::api-token").findMany({ where: { type: "full-access" } })
+  ]);
+  if (!site || !token) {
+    throw new Error("You need to configure Site url and a full-access API token first.");
+  }
+  const accessKey = strapi.service("admin::encryption").decrypt(token.encryptedKey);
+  return {
+    url: site?.url,
+    token: accessKey
+  };
+};
+var buildHeaders = (token, extraHeaders = {}) => {
+  const headers = { ...extraHeaders };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+};
+var fetchWebsite = async (endpoint, options = {}) => {
+  const { url, token } = await getWebsiteConfig();
+  const fullUrl = `${url}${endpoint}`;
+  console.debug("Fetch Website Server Url:", fullUrl);
+  const headers = buildHeaders(token, options.headers);
+  const response = await fetch(fullUrl, { ...options, headers });
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const result = await response.json();
+  return result;
+};
+var handleError = (ctx, error, defaultMessage) => {
+  const timestamp = new Date().toISOString();
+  let code = 500;
+  let message = error.message || defaultMessage;
+  if (error.status === 404 || error.message?.includes("404")) {
+    code = 404;
+    message = error.message || "Resource not found";
+  } else if (error.status === 400 || error.message?.includes("400")) {
+    code = 400;
+    message = error.message || "Bad request";
+  } else if (error.status === 401 || error.message?.includes("401")) {
+    code = 401;
+    message = error.message || "Unauthorized";
+  } else if (error.status === 403 || error.message?.includes("403")) {
+    code = 403;
+    message = error.message || "Forbidden";
+  }
+  const errorResponse = {
+    code,
+    message: `${defaultMessage}: ${message}`,
+    timestamp
+  };
+  ctx.status = code;
+  return errorResponse;
+};
+var buildQueryParams = (params) => {
+  const queryParams = new URLSearchParams;
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null && value !== "") {
+      queryParams.append(key, String(value));
+    }
+  });
+  return queryParams.toString();
+};
+var paginateData = (data, limit, offset) => {
+  const total = data.length;
+  const startIndex = offset;
+  const endIndex = startIndex + limit;
+  const items = data.slice(startIndex, endIndex);
+  return {
+    code: 200,
+    message: "success",
+    data: {
+      items,
+      pagination: {
+        page: Math.floor(offset / limit) + 1,
+        pageSize: limit,
+        total
+      }
+    },
+    timestamp: new Date().toISOString()
+  };
+};
+
+// server/src/controllers/inquiries.ts
+var list = async (ctx) => {
+  const {
+    page = 1,
+    pageSize = 10,
+    keyword = "",
+    start = "",
+    end = "",
+    sortBy = "createdAt",
+    order = "desc"
+  } = ctx.query;
+  const queryString = buildQueryParams({
+    page,
+    pageSize,
+    keyword,
+    start,
+    end,
+    sortBy,
+    order
+  });
+  try {
+    return await fetchWebsite(`/api/inquiries?${queryString}`);
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch inquiries");
+  }
+};
+var detail = async (ctx) => {
+  const { id } = ctx.params;
+  try {
+    return await fetchWebsite(`/api/inquiries/${id}`);
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch inquiry detail");
+  }
+};
+var read = async (ctx) => {
+  const { id } = ctx.params;
+  const operatorId = ctx.state?.user?.id;
+  if (!operatorId) {
+    ctx.throw(400, "operatorId is required");
+  }
+  try {
+    return await fetchWebsite(`/api/inquiries/${id}/read`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ operatorId })
+    });
+  } catch (error) {
+    return handleError(ctx, error, "Failed to mark inquiry as read");
+  }
+};
+var inquiries = {
+  list,
+  detail,
+  read
+};
+var inquiries_default = inquiries;
+
+// server/src/controllers/visitors.ts
+var pageViews = async (ctx) => {
+  const { limit = 10, offset = 0, start, end, ip } = ctx.query;
+  const queryString = buildQueryParams({ start, end, ip });
+  try {
+    const allData = await fetchWebsite(`/api/visitor/page-views?${queryString}`);
+    return paginateData(allData, Number(limit), Number(offset));
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch page views");
+  }
+};
+var sessions = async (ctx) => {
+  const { limit = 10, offset = 0, start, end, ip } = ctx.query;
+  const queryString = buildQueryParams({ start, end, ip });
+  try {
+    const allData = await fetchWebsite(`/api/visitor/sessions?${queryString}`);
+    return paginateData(allData, Number(limit), Number(offset));
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch visitor sessions");
+  }
+};
+var dailyPageStats = async (ctx) => {
+  const { start, end, page, limit = 10, offset = 0 } = ctx.query;
+  const queryString = buildQueryParams({ start, end, page });
+  try {
+    const allData = await fetchWebsite(`/api/visitor/stats/daily-page?${queryString}`);
+    return paginateData(allData, Number(limit), Number(offset));
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch daily page stats");
+  }
+};
+var visitors = {
+  pageViews,
+  sessions,
+  dailyPageStats
+};
+var visitors_default = visitors;
+
+// server/src/controllers/website.ts
+var hello = async () => {
+  return { message: "hello world" };
+};
+var refresh = async (ctx) => {
+  try {
+    return await fetchWebsite("/api/site/refresh");
+  } catch (error) {
+    return handleError(ctx, error, "Failed to refresh website cache");
+  }
+};
+var dashboard = async (ctx) => {
+  try {
+    return await fetchWebsite("/api/common/dashboard");
+  } catch (error) {
+    return handleError(ctx, error, "Failed to fetch dashboard stats");
+  }
+};
+var website = {
+  hello,
+  refresh,
+  dashboard
+};
+var website_default = website;
 
 // server/src/controllers/index.ts
-var controllers = {};
-var controllers_default = controllers;
+var controllers2 = {
+  website: website_default,
+  visitors: visitors_default,
+  inquiries: inquiries_default,
+  fields: fields_default
+};
+var controllers_default = controllers2;
 
 // server/src/destroy.ts
-var destroy = ({ strapi }) => {
-  strapi.log.info("dashboard server plugin: bootstrap");
+var destroy = ({ strapi: strapi2 }) => {
+  strapi2.log.info("dashboard server plugin: bootstrap");
 };
 var destroy_default = destroy;
 
+// server/src/components/index.ts
+var createComponent = (strapi2, { name, displayName, icon, attributes }) => {
+  const category = "website";
+  if (strapi2.components[`${category}.${name}`])
+    return;
+  const builder = strapi2.plugin("content-type-builder");
+  builder.services.components.createComponent({
+    component: {
+      icon,
+      category,
+      displayName,
+      attributes
+    }
+  }).then((r) => {
+    console.log(`create ${name} component`, r);
+  });
+};
+var registerComponents = (strapi2, components) => {
+  components.forEach((component) => {
+    createComponent(strapi2, component);
+  });
+};
+
+// server/src/components/banner.ts
+var component = {
+  name: "banner",
+  icon: "landscape",
+  displayName: "Banner",
+  attributes: {
+    title: {
+      type: "string"
+    },
+    subtitle: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    image: {
+      type: "media",
+      multiple: false,
+      required: true,
+      allowedTypes: ["images"]
+    },
+    mImage: {
+      type: "media",
+      multiple: false,
+      allowedTypes: ["images"]
+    }
+  }
+};
+var banner_default = component;
+
+// server/src/components/logo.ts
+var component2 = {
+  name: "logo",
+  icon: "picture",
+  displayName: "Logo",
+  attributes: {
+    main: {
+      type: "media",
+      multiple: false,
+      allowedTypes: ["images"]
+    },
+    sub: {
+      type: "media",
+      multiple: false,
+      allowedTypes: ["images"]
+    }
+  }
+};
+var logo_default = component2;
+
+// server/src/components/social.ts
+var component3 = {
+  name: "social",
+  icon: "paperPlane",
+  displayName: "Social",
+  attributes: {
+    type: {
+      type: "enumeration",
+      enum: ["url", "qrcode"]
+    },
+    url: {
+      type: "string",
+      conditions: {
+        visible: {
+          "==": [
+            {
+              var: "type"
+            },
+            "url"
+          ]
+        }
+      }
+    },
+    qrcode: {
+      type: "media",
+      conditions: {
+        visible: {
+          "==": [
+            {
+              var: "type"
+            },
+            "qrcode"
+          ]
+        }
+      },
+      multiple: false,
+      allowedTypes: ["images"]
+    }
+  }
+};
+var social_default = component3;
+
+// server/src/components/video.ts
+var component4 = {
+  name: "video",
+  icon: "play",
+  displayName: "Video",
+  attributes: {
+    url: {
+      type: "string",
+      required: true
+    },
+    title: {
+      type: "string"
+    },
+    image: {
+      type: "media",
+      multiple: false,
+      allowedTypes: ["images"]
+    }
+  }
+};
+var video_default = component4;
+
 // server/src/register.ts
-var register = ({ strapi }) => {
-  strapi.log.info("dashboard server plugin: bootstrap");
+var register = ({ strapi: strapi2 }) => {
+  strapi2.log.info("website server plugin: register");
+  registerComponents(strapi2, [
+    banner_default,
+    social_default,
+    logo_default,
+    video_default
+  ]);
+  strapi2.customFields.register([
+    {
+      name: "slugInput",
+      plugin: "website",
+      type: "string",
+      inputSize: {
+        default: 6,
+        isResizable: true
+      }
+    },
+    {
+      name: "dataNested",
+      plugin: "website",
+      type: "json",
+      inputSize: {
+        default: 12,
+        isResizable: false
+      }
+    },
+    {
+      name: "dataSelect",
+      plugin: "website",
+      type: "json",
+      inputSize: {
+        default: 12,
+        isResizable: false
+      }
+    },
+    {
+      name: "iconPicker",
+      plugin: "website",
+      type: "json",
+      inputSize: {
+        default: 4,
+        isResizable: true
+      }
+    },
+    {
+      name: "colorPicker",
+      plugin: "website",
+      type: "string",
+      inputSize: {
+        default: 4,
+        isResizable: true
+      }
+    }
+  ]);
 };
 var register_default = register;
 
 // server/src/routes/index.ts
-var routes = {
+var routes2 = {
   admin: {
     type: "admin",
     routes: [
+      {
+        method: "POST",
+        path: "/fields/check-available",
+        handler: "fields.checkAvailable",
+        info: {}
+      },
       {
         method: "GET",
-        path: "/website/hello",
+        path: "/hello",
         handler: "website.hello",
         config: { auth: false },
         info: {}
       },
       {
         method: "GET",
-        path: "/website/refresh",
+        path: "/refresh",
         handler: "website.refresh",
         config: {},
         info: {}
       },
       {
         method: "GET",
-        path: "/website/dashboard",
+        path: "/dashboard",
         handler: "website.dashboard",
         config: {},
         info: {}
@@ -89,68 +892,77 @@ var routes = {
       {
         method: "GET",
         path: "/inquiries",
-        handler: "inquiry.list",
+        handler: "inquiries.list",
         config: {},
         info: {}
       },
       {
         method: "GET",
         path: "/inquiries/:id",
-        handler: "inquiry.detail",
+        handler: "inquiries.detail",
         config: {},
         info: {}
       },
       {
         method: "PUT",
         path: "/inquiries/:id/read",
-        handler: "inquiry.markAsRead",
+        handler: "inquiries.read",
         config: {},
         info: {}
       },
       {
         method: "GET",
         path: "/visitors/page-views",
-        handler: "visitor.pageViews",
+        handler: "visitors.pageViews",
         config: {},
         info: {}
       },
       {
         method: "GET",
         path: "/visitors/sessions",
-        handler: "visitor.sessions",
+        handler: "visitors.sessions",
         config: {},
         info: {}
       },
       {
         method: "GET",
         path: "/visitors/stats/daily-page",
-        handler: "visitor.dailyPageStats",
+        handler: "visitors.dailyPageStats",
         config: {},
         info: {}
       }
     ]
   }
 };
-var routes_default = routes;
+var routes_default = routes2;
 
 // server/src/services/index.ts
-var services = {};
-var services_default = services;
+var services2 = {};
+var services_default = services2;
 
 // server/src/index.ts
 var plugin = {
   register: register_default,
   bootstrap: bootstrap_default,
   destroy: destroy_default,
-  controllers: controllers_default,
-  routes: routes_default,
-  services: services_default,
-  contentTypes: contentTypes_default,
+  config: config_default,
+  contentTypes: {
+    ...contentTypes_default,
+    ...api_default.contentTypes
+  },
+  controllers: {
+    ...controllers_default,
+    ...api_default.controllers
+  },
+  routes: {
+    ...routes_default,
+    ...api_default.routes
+  },
+  services: {
+    ...services_default,
+    ...api_default.services
+  },
   policies: {},
-  middlewares: {},
-  config: {
-    default: {},
-    validator: () => {}
-  }
+  middlewares: {}
 };
 var src_default = plugin;