@smi-digital/create-smi-app 2.3.1 → 2.4.0

package/dist/index.js

@@ -92,16 +92,16 @@ function asFramework(value) {
 }
 
 // src/modules/integrations.ts
-import { readFile, readdir } from "fs/promises";
-import { join } from "path";
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join2 } from "path";
 async function loadIntegrationConfig(templatesDir, integrationKey) {
-  const configPath = join(
+  const configPath = join2(
     templatesDir,
     "integrations",
     integrationKey,
     "integration.config.json"
   );
-  const rawContent = await readFile(configPath, "utf8");
+  const rawContent = await readFile2(configPath, "utf8");
   return JSON.parse(rawContent);
 }
 function matchesIntegration(selection, config) {
@@ -121,7 +121,7 @@ function matchesIntegration(selection, config) {
   return true;
 }
 async function getIntegrationForSelection(templatesDir, selection) {
-  const integrationsRoot = join(templatesDir, "integrations");
+  const integrationsRoot = join2(templatesDir, "integrations");
   const entries = await readdir(integrationsRoot, { withFileTypes: true });
   const folders = entries.filter((entry) => entry.isDirectory());
   const findSequentially = async (index) => {
@@ -274,17 +274,17 @@ async function askQuestions(templatesDir) {
 
 // src/modules/init.ts
 import { fileURLToPath } from "url";
-import { join as join2, dirname } from "path";
+import { join as join3, dirname } from "path";
 import { access } from "fs/promises";
 async function resolveTemplatesDir(currentDir) {
   const candidates = [
-    join2(currentDir, "../../templates"),
-    join2(currentDir, "../templates")
+    join3(currentDir, "../../templates"),
+    join3(currentDir, "../templates")
   ];
   const checks = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access(join2(candidate, "base"));
+        await access(join3(candidate, "base"));
         return true;
       } catch {
         return false;
@@ -311,11 +311,11 @@ async function init() {
 
 // src/modules/createScaffold.ts
 import { access as access2, mkdir as mkdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/modules/scaffoldActions/createTools.ts
-import { cp, readFile as readFile2, readdir as readdir2, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { cp, readFile as readFile3, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
 var templateRenameMap = {
   "env.template": ".env",
   "gitignore.template": ".gitignore",
@@ -337,32 +337,32 @@ function toPackageName(projectName) {
   return normalized || "app";
 }
 async function updatePackageJsonName(targetDir, projectName) {
-  const packageJsonPath = join3(targetDir, "package.json");
-  const packageJsonRaw = await readFile2(packageJsonPath, "utf8");
+  const packageJsonPath = join4(targetDir, "package.json");
+  const packageJsonRaw = await readFile3(packageJsonPath, "utf8");
   const packageJson = JSON.parse(packageJsonRaw);
   packageJson.name = toPackageName(projectName);
-  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  await writeFile2(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
 }
 async function createTools(tools, targetDir, templatesDir, projectName) {
   if (!tools.includes("basic")) {
     return;
   }
-  const baseToolsDir = join3(templatesDir, "base");
-  const huskyDir = join3(templatesDir, ".husky");
+  const baseToolsDir = join4(templatesDir, "base");
+  const huskyDir = join4(templatesDir, ".husky");
   const entries = await readdir2(baseToolsDir, { withFileTypes: true });
   await Promise.all(
     entries.map(
       (entry) => cp(
-        join3(baseToolsDir, entry.name),
-        join3(targetDir, getTargetFileName(entry.name)),
+        join4(baseToolsDir, entry.name),
+        join4(targetDir, getTargetFileName(entry.name)),
         {
           recursive: true
         }
       )
     )
   );
-  await cp(huskyDir, join3(targetDir, ".husky"), {
+  await cp(huskyDir, join4(targetDir, ".husky"), {
     recursive: true
   });
   await updatePackageJsonName(targetDir, projectName);
@@ -478,14 +478,30 @@ async function createApps(projectRoot, targets) {
       return;
     }
     await createFrameworkApp(projectRoot, target);
+    if (target.framework === "strapi") {
+      try {
+        const pluginsPath = join(
+          projectRoot,
+          target.directory,
+          "config/plugins.ts"
+        );
+        let pluginsContent = await readFile(pluginsPath, "utf8");
+        pluginsContent = pluginsContent.replace(
+          "export default ({ env }) => ({",
+          "export default () => ({"
+        );
+        await writeFile(pluginsPath, pluginsContent);
+      } catch {
+      }
+    }
     await runSequentially(index + 1);
   };
   await runSequentially(0);
 }
 
 // src/modules/scaffoldActions/createIntegrations.ts
-import { mkdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { mkdir, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
 import { randomBytes } from "crypto";
 function toTemplateToken(key) {
   const normalized = key.replaceAll(/[^a-zA-Z0-9]+/gv, "_").replaceAll(/^_+|_+$/gv, "").toUpperCase();
@@ -499,10 +515,10 @@ function applyTemplateVariables(content, values) {
   return result;
 }
 async function copyTemplateFile(sourcePath, targetPath, values) {
-  const rawContent = await readFile3(sourcePath, "utf8");
+  const rawContent = await readFile4(sourcePath, "utf8");
   const content = applyTemplateVariables(rawContent, values);
   await mkdir(dirname2(targetPath), { recursive: true });
-  await writeFile2(targetPath, content, "utf8");
+  await writeFile3(targetPath, content, "utf8");
 }
 async function createIntegrations(options, projectRoot, templatesDir) {
   const { projectType } = options;
@@ -529,7 +545,7 @@ async function createIntegrations(options, projectRoot, templatesDir) {
     templatesDir,
     integrationKey
   );
-  const integrationRoot = join4(templatesDir, "integrations", integrationKey);
+  const integrationRoot = join5(templatesDir, "integrations", integrationKey);
   const filesToApply = [];
   if (integrationConfig.workflows) {
     if (integrationConfig.workflows.prValidation)
@@ -567,8 +583,8 @@ async function createIntegrations(options, projectRoot, templatesDir) {
       /* eslint-enable camelcase */
     };
     return copyTemplateFile(
-      join4(integrationRoot, file.template),
-      join4(projectRoot, file.target),
+      join5(integrationRoot, file.template),
+      join5(projectRoot, file.target),
       templateValues
     );
   });
@@ -611,19 +627,19 @@ function getAppTargets(options) {
 }
 async function createProjectStructure(options, projectRoot) {
   if (options.projectType === "singleProject" && "framework" in options && asFramework(options.framework) === "none") {
-    await mkdir2(join5(projectRoot, "src"), { recursive: true });
+    await mkdir2(join6(projectRoot, "src"), { recursive: true });
     return;
   }
   if (options.projectType !== "monorepo") {
     return;
   }
   await Promise.all([
-    mkdir2(join5(projectRoot, "backend"), { recursive: true }),
-    mkdir2(join5(projectRoot, "frontend"), { recursive: true })
+    mkdir2(join6(projectRoot, "backend"), { recursive: true }),
+    mkdir2(join6(projectRoot, "frontend"), { recursive: true })
   ]);
 }
 async function initializeGitRepository(projectRoot) {
-  const gitDir = join5(projectRoot, ".git");
+  const gitDir = join6(projectRoot, ".git");
   try {
     await access2(gitDir);
     return;
@@ -643,7 +659,7 @@ async function createScaffold(options, targetDir, templatesDir) {
     throw new Error("Project name cannot be empty.");
   }
   console.log();
-  const projectRoot = join5(targetDir, projectName);
+  const projectRoot = join6(targetDir, projectName);
   await runStep(
     "Creating project folder",
     async () => mkdir2(projectRoot, { recursive: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smi-digital/create-smi-app",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "",
   "main": "dist/index.js",
   "bin": {

package/templates/base/package.json.template

@@ -33,6 +33,7 @@
     "knip": "^5.86.0",
     "lint-staged": "^16.3.3",
     "prettier": "3.8.1",
+    "prettier-plugin-astro": "^0.13.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.0"

package/templates/base/prettierrc.template

@@ -1 +1,11 @@
-{}
+{
+  "plugins": ["prettier-plugin-astro"],
+  "overrides": [
+    {
+      "files": "*.astro",
+      "options": {
+        "parser": "astro"
+      }
+    }
+  ]
+}

package/templates/integrations/strapi-astro/Dockerfile.backend.template

@@ -13,7 +13,7 @@ WORKDIR /opt/
 COPY package.json ./
 RUN npm install -g node-gyp
 RUN npm config set fetch-retry-maxtimeout 600000 -g && npm install --only=production
-ENV PATH /opt/node_modules/.bin:$PATH
+ENV PATH=/opt/node_modules/.bin:$PATH
 
 WORKDIR /opt/app
 COPY . .

package/templates/integrations/strapi-astro/Dockerfile.frontend.ssr.template

@@ -6,7 +6,7 @@
 # Stage 1: Build with Bun
 FROM oven/bun:1 as builder
 WORKDIR /app
-COPY package.json bun.lock ./
+COPY package.json package-lock.json ./
 RUN bun install
 COPY . .
 RUN bun run build