crdncli 1.0.3

package/LICENSE

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) 2026 Creiden
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

package/README.md

@@ -0,0 +1,57 @@
+# crdncli
+
+CLI tools by **Creiden** for scaffolding parts of a CRDN-style Next.js app.
+
+## Install
+
+```bash
+npm i -g crdncli
+```
+
+## Commands
+
+### `crdn add-feature [name]`
+
+Creates a new feature in `src/features/<name>` based on the template shipped with this package.
+
+If your app has tests, it also copies feature unit tests to:
+
+- `tests/unit/features/<name>`
+
+Examples:
+
+```bash
+crdn add-feature auth
+crdn add-feature billing
+```
+
+### `crdn add-lang [code]`
+
+Adds a new language file to `/messages` based on the existing JSON structure (values are created empty),
+and tries to register the locale in `src/lib/i18n/routing.ts` if present.
+
+Examples:
+
+```bash
+crdn add-lang fr
+crdn add-lang ar
+```
+
+### `crdn delete-lang [code]`
+
+Deletes `/messages/<code>.json` (if it exists) and removes the locale from `src/lib/i18n/routing.ts` (if it exists).
+You’ll be prompted to confirm with **y/N** before anything is deleted.
+
+Examples:
+
+```bash
+crdn delete-lang fr
+crdn delete-lang ar
+```
+
+## Help
+
+```bash
+crdn --help
+crdn --version
+```

package/bin/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { createProgram } = require("../lib/cli");
+
+createProgram().parse(process.argv);

package/commands/addFeature.js

@@ -0,0 +1,194 @@
+const fs = require("fs-extra");
+const path = require("path");
+const chalk = require("chalk");
+const readline = require("readline");
+
+/**
+ * crdn add-feature <name>
+ *
+ * - Must be run from the root of a CRDN Next.js app (the app created by `create-crdn-app`)
+ * - Copies the template feature from `crdn/templates/feature` into `src/features/<name>`
+ * - Performs simple text replacements so you can base new features on the auth example
+ */
+
+function run(featureName) {
+  const appRoot = process.cwd();
+
+  const srcDir = path.join(appRoot, "src");
+  if (!fs.existsSync(srcDir)) {
+    console.error(
+      chalk.red(
+        "This command must be run from the root of a CRDN Next.js app (missing `src/`)."
+      )
+    );
+    process.exit(1);
+  }
+
+  const targetFeatureDir = path.join(appRoot, "src", "features", featureName);
+
+  if (fs.existsSync(targetFeatureDir)) {
+    console.error(
+      chalk.red(
+        `Feature \`${featureName}\` already exists at src/features/${featureName}.`
+      )
+    );
+    process.exit(1);
+  }
+
+  // Resolve the template directory inside the installed `crdn` package.
+  // When installed globally or locally, `__dirname` will be `<packageRoot>/commands`.
+  const templateDir = path.join(__dirname, "..", "templates", "feature");
+
+  if (!fs.existsSync(templateDir)) {
+    console.error(
+      chalk.red("Could not find feature templates inside the `crdn` package.`")
+    );
+    process.exit(1);
+  }
+
+  // Copy the template directory into the feature folder (excluding tests)
+  fs.copySync(templateDir, targetFeatureDir, {
+    filter: (src) => !src.includes(`${path.sep}tests${path.sep}`),
+  });
+
+  // After copying, apply simple content/name replacements so the template
+  // can be based on `auth` but work for any feature name.
+  const featureNameCamel =
+    featureName.charAt(0).toLowerCase() + featureName.slice(1);
+  const featureNamePascal =
+    featureName.charAt(0).toUpperCase() + featureName.slice(1);
+
+  const replaceInFile = (filePath) => {
+    if (!fs.existsSync(filePath)) return;
+
+    let content = fs.readFileSync(filePath, "utf8");
+
+    // Fix up template-relative import paths that depend on renamed files
+    content = content
+      .replace(/\.\/components\/feature\b/g, `./components/${featureNamePascal}`)
+      .replace(/\.\/hooks\/useFeature\b/g, `./hooks/use${featureNamePascal}`)
+      .replace(/\.\/api\/featureApi\b/g, `./api/${featureNameCamel}Api`)
+      .replace(/\.\/types\/feature\.types\b/g, `./types/${featureNameCamel}.types`)
+      .replace(/\.\.\/api\/featureApi\b/g, `../api/${featureNameCamel}Api`)
+      .replace(/\.\.\/hooks\/useFeature\b/g, `../hooks/use${featureNamePascal}`)
+      .replace(/\.\.\/types\/feature\.types\b/g, `../types/${featureNameCamel}.types`);
+
+    // Basic convention: templates may use these placeholders.
+    content = content
+      .replace(/__FEATURE_PASCAL__/g, featureNamePascal)
+      .replace(/__FEATURE_CAMEL__/g, featureNameCamel)
+      .replace(/__FEATURE_RAW__/g, featureName);
+
+    // Also, if the template is auth/feature-based, rename obvious identifiers:
+    content = content
+      // old auth-based names
+      .replace(/\bauthKeys\b/g, `${featureNameCamel}Keys`)
+      .replace(/\bauthApi\b/g, `${featureNameCamel}Api`)
+      .replace(/\bAuth\b/g, featureNamePascal)
+      .replace(/\bauth\b/g, featureNameCamel)
+      // new generic feature-based names
+      .replace(/\bfeatureKeys\b/g, `${featureNameCamel}Keys`)
+      .replace(/\bfeatureApi\b/g, `${featureNameCamel}Api`)
+      .replace(/\buseFeature\b/g, `use${featureNamePascal}`);
+
+    fs.writeFileSync(filePath, content, "utf8");
+  };
+
+  const walk = (dir) => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      let fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else {
+        // Rename template files to match the new feature name
+        let newName = entry.name;
+
+        if (newName === "featureApi.ts") {
+          newName = `${featureNameCamel}Api.ts`;
+        } else if (newName === "useFeature.ts") {
+          newName = `use${featureNamePascal}.ts`;
+        } else if (newName === "feature.types.ts") {
+          newName = `${featureNameCamel}.types.ts`;
+        } else if (newName === "feature.tsx") {
+          // main UI component file
+          newName = `${featureNamePascal}.tsx`;
+        } else if (newName === "featureApi.smoke.test.ts") {
+          newName = `${featureNameCamel}Api.smoke.test.ts`;
+        } else if (newName === "featureKeys.test.ts") {
+          newName = `${featureNameCamel}Keys.test.ts`;
+        } else if (newName === "feature.barrel.test.ts") {
+          newName = `${featureNameCamel}.barrel.test.ts`;
+        }
+
+        if (newName !== entry.name) {
+          const newPath = path.join(dir, newName);
+          fs.renameSync(fullPath, newPath);
+          fullPath = newPath;
+        }
+
+        replaceInFile(fullPath);
+      }
+    }
+  };
+
+  walk(targetFeatureDir);
+
+  // Copy tests (following the Next.js template convention)
+  const appTestsFeatureDir = path.join(
+    appRoot,
+    "tests",
+    "unit",
+    "features",
+    featureNameCamel
+  );
+  const templateTestsFeatureDir = path.join(
+    templateDir,
+    "tests",
+    "unit",
+    "features",
+    "feature"
+  );
+
+  if (
+    fs.existsSync(path.join(appRoot, "tests")) &&
+    fs.existsSync(templateTestsFeatureDir)
+  ) {
+    fs.ensureDirSync(appTestsFeatureDir);
+    fs.copySync(templateTestsFeatureDir, appTestsFeatureDir);
+
+    // Apply replacements + renames inside the copied tests folder
+    walk(appTestsFeatureDir);
+  }
+
+  console.log(
+    chalk.green(
+      `Feature \`${featureName}\` created at src/features/${featureName}.`
+    )
+  );
+}
+
+module.exports = function addFeature(featureName) {
+  if (featureName) {
+    run(featureName);
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  rl.question(chalk.cyan("Enter feature name: "), (answer) => {
+    rl.close();
+
+    const trimmed = answer.trim();
+    if (!trimmed) {
+      console.error(chalk.red("Feature name is required."));
+      process.exit(1);
+    }
+
+    run(trimmed);
+  });
+};

package/commands/addLang.js

@@ -0,0 +1,162 @@
+const fs = require("fs-extra");
+const path = require("path");
+const chalk = require("chalk");
+const readline = require("readline");
+
+function askForCode(onDone) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  rl.question(chalk.cyan("Enter language code (e.g. fr, es): "), (answer) => {
+    rl.close();
+    const code = answer.trim();
+
+    if (!code) {
+      console.error(chalk.red("Language code is required."));
+      process.exit(1);
+    }
+
+    onDone(code);
+  });
+}
+
+function run(code) {
+  const appRoot = process.cwd();
+  const messagesDir = path.join(appRoot, "messages");
+  const preferredBasePath = path.join(messagesDir, "en.json");
+  const routingPath = path.join(appRoot, "src", "lib", "i18n", "routing.ts");
+
+  const resolveBaseMessagesPath = () => {
+    if (fs.existsSync(preferredBasePath)) return preferredBasePath;
+    if (!fs.existsSync(messagesDir)) return null;
+
+    const entries = fs.readdirSync(messagesDir);
+    const jsonFiles = entries
+      .filter((name) => name.toLowerCase().endsWith(".json"))
+      .sort((a, b) => a.localeCompare(b));
+
+    if (jsonFiles.length === 0) return null;
+    return path.join(messagesDir, jsonFiles[0]);
+  };
+
+  const baseMessagesPath = resolveBaseMessagesPath();
+
+  if (!baseMessagesPath) {
+    console.error(
+      chalk.red(
+        "Could not find any `messages/*.json` to use as a base. Make sure you run this in a CRDN Next.js app with a /messages folder containing at least one JSON file."
+      )
+    );
+    process.exit(1);
+  }
+
+  const targetPath = path.join(messagesDir, `${code}.json`);
+
+  if (fs.existsSync(targetPath)) {
+    console.error(
+      chalk.red(`Language file \`${code}.json\` already exists in /messages.`)
+    );
+    process.exit(1);
+  }
+
+  const baseMessages = fs.readJsonSync(baseMessagesPath);
+
+  const cloneWithEmptyValues = (node) => {
+    if (node === null || node === undefined) return node;
+
+    if (typeof node === "string") {
+      return "";
+    }
+
+    if (Array.isArray(node)) {
+      return node.map(cloneWithEmptyValues);
+    }
+
+    if (typeof node === "object") {
+      const result = {};
+      for (const key of Object.keys(node)) {
+        result[key] = cloneWithEmptyValues(node[key]);
+      }
+      return result;
+    }
+
+    return node;
+  };
+
+  const newMessages = cloneWithEmptyValues(baseMessages);
+
+  fs.ensureDirSync(messagesDir);
+  fs.writeJsonSync(targetPath, newMessages, { spaces: 2 });
+
+  console.log(
+    chalk.green(`Created messages file: messages/${code}.json (values empty).`)
+  );
+
+  // Try to register the new locale in src/lib/i18n/routing.ts
+  if (!fs.existsSync(routingPath)) {
+    console.warn(
+      chalk.yellow(
+        "Could not find `src/lib/i18n/routing.ts` to register the new locale. Please add it manually."
+      )
+    );
+    return;
+  }
+
+  let routingSource = fs.readFileSync(routingPath, "utf8");
+
+  const localesMatch = routingSource.match(/locales\s*:\s*\[([^\]]*)\]/);
+
+  if (!localesMatch) {
+    console.warn(
+      chalk.yellow(
+        "Could not find `locales: [...]` in `src/lib/i18n/routing.ts`. Please add the new locale manually."
+      )
+    );
+    return;
+  }
+
+  const inner = localesMatch[1];
+
+  const existingLocales = inner
+    .split(",")
+    .map((part) => part.trim().replace(/^"(.+)"$/, "$1").replace(/^'(.+)'$/, "$1"))
+    .filter(Boolean);
+
+  if (existingLocales.includes(code)) {
+    console.log(
+      chalk.yellow(
+        `Locale \`${code}\` is already present in src/lib/i18n/routing.ts.`
+      )
+    );
+    return;
+  }
+
+  const newInner = `${inner.trim()}${
+    inner.trim().length ? ", " : ""
+  }"${code}"`;
+
+  routingSource = routingSource.replace(
+    /locales\s*:\s*\[([^\]]*)\]/,
+    `locales: [${newInner}]`
+  );
+
+  fs.writeFileSync(routingPath, routingSource, "utf8");
+
+  console.log(
+    chalk.green(
+      `Registered locale \`${code}\` in src/lib/i18n/routing.ts.`
+    )
+  );
+}
+
+module.exports = function addLang(code) {
+  if (code) {
+    run(code);
+    return;
+  }
+
+  askForCode(run);
+};
+

package/commands/deleteLang.js

@@ -0,0 +1,132 @@
+const fs = require("fs-extra");
+const path = require("path");
+const chalk = require("chalk");
+const readline = require("readline");
+
+function ask(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+async function askForCode() {
+  const answer = await ask(chalk.cyan("Enter language code (e.g. fr, es): "));
+  return answer.trim();
+}
+
+async function confirmDelete(code) {
+  const answer = await ask(
+    chalk.yellow(
+      `Are you sure you want to delete language "${code}"? This will remove messages/${code}.json and update routing.ts. (y/N): `
+    )
+  );
+  const normalized = answer.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+
+function removeLocaleFromRouting(routingPath, code) {
+  if (!fs.existsSync(routingPath)) {
+    console.warn(
+      chalk.yellow(
+        "Could not find `src/lib/i18n/routing.ts` to unregister the locale. Skipping."
+      )
+    );
+    return { updated: false, removed: false };
+  }
+
+  let routingSource = fs.readFileSync(routingPath, "utf8");
+
+  const localesMatch = routingSource.match(/locales\s*:\s*\[([^\]]*)\]/);
+  if (!localesMatch) {
+    console.warn(
+      chalk.yellow(
+        "Could not find `locales: [...]` in `src/lib/i18n/routing.ts`. Skipping."
+      )
+    );
+    return { updated: false, removed: false };
+  }
+
+  const inner = localesMatch[1];
+  const existingLocales = inner
+    .split(",")
+    .map((part) =>
+      part.trim().replace(/^"(.+)"$/, "$1").replace(/^'(.+)'$/, "$1")
+    )
+    .filter(Boolean);
+
+  if (!existingLocales.includes(code)) {
+    return { updated: false, removed: false };
+  }
+
+  const nextLocales = existingLocales.filter((l) => l !== code);
+  const nextInner = nextLocales.map((l) => `"${l}"`).join(", ");
+
+  routingSource = routingSource.replace(
+    /locales\s*:\s*\[([^\]]*)\]/,
+    `locales: [${nextInner}]`
+  );
+
+  fs.writeFileSync(routingPath, routingSource, "utf8");
+  return { updated: true, removed: true };
+}
+
+function deleteMessagesFile(messagesDir, code) {
+  const targetPath = path.join(messagesDir, `${code}.json`);
+
+  if (!fs.existsSync(targetPath)) {
+    return { deleted: false };
+  }
+
+  fs.removeSync(targetPath);
+  return { deleted: true };
+}
+
+async function run(code) {
+  const appRoot = process.cwd();
+  const messagesDir = path.join(appRoot, "messages");
+  const routingPath = path.join(appRoot, "src", "lib", "i18n", "routing.ts");
+
+  const confirmed = await confirmDelete(code);
+  if (!confirmed) {
+    console.log(chalk.yellow("Cancelled."));
+    return;
+  }
+
+  const { deleted } = deleteMessagesFile(messagesDir, code);
+  if (deleted) {
+    console.log(chalk.green(`Deleted messages/${code}.json`));
+  } else {
+    console.log(chalk.yellow(`messages/${code}.json not found (skipped).`));
+  }
+
+  const routingResult = removeLocaleFromRouting(routingPath, code);
+  if (routingResult.removed) {
+    console.log(
+      chalk.green(`Removed locale "${code}" from src/lib/i18n/routing.ts`)
+    );
+  } else {
+    console.log(
+      chalk.yellow(`Locale "${code}" not found in routing.ts (skipped).`)
+    );
+  }
+}
+
+module.exports = async function deleteLang(code) {
+  const resolvedCode = code ? String(code).trim() : await askForCode();
+
+  if (!resolvedCode) {
+    console.error(chalk.red("Language code is required."));
+    process.exit(1);
+  }
+
+  await run(resolvedCode);
+};
+

package/lib/cli.js

@@ -0,0 +1,37 @@
+const { Command } = require("commander");
+
+const addFeature = require("../commands/addFeature");
+const addLang = require("../commands/addLang");
+const deleteLang = require("../commands/deleteLang");
+
+function createProgram() {
+  const program = new Command();
+
+  program
+    .name("crdn")
+    .description("CRDN CLI tools")
+    .version(require("../package.json").version);
+
+  program
+    .command("add-feature")
+    .description("Create a new feature from template")
+    .argument("[name]")
+    .action(addFeature);
+
+  program
+    .command("add-lang")
+    .description("Add a new language messages file")
+    .argument("[code]")
+    .action(addLang);
+
+  program
+    .command("delete-lang")
+    .description("Delete a language messages file and unregister locale")
+    .argument("[code]")
+    .action(deleteLang);
+
+  return program;
+}
+
+module.exports = { createProgram };
+

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "crdncli",
+  "version": "1.0.3",
+  "description": "",
+  "main": "bin/index.js",
+  "bin": {
+    "crdn": "bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepack": "node -c ./bin/index.js && node -c ./lib/cli.js && node -c ./commands/addFeature.js && node -c ./commands/addLang.js && node -c ./commands/deleteLang.js"
+  },
+  "keywords": [],
+  "author": "Creiden",
+  "homepage": "https://creiden.com/",
+  "license": "ISC",
+  "type": "commonjs",
+  "files": [
+    "bin",
+    "lib",
+    "commands",
+    "templates",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.2.0"
+  }
+}

package/templates/feature/api/featureApi.ts

@@ -0,0 +1,36 @@
+import { get, post, put, del } from "@/lib/api/client";
+
+const BASE_PATH = "/__FEATURE_RAW__";
+
+// Basic CRUD helpers for the __FEATURE_RAW__ endpoint.
+// Each function exposes a generic so callers can override the response type.
+
+export async function list__FEATURE_PASCAL__s<T = unknown>(): Promise<T[]> {
+  return get<T[]>(BASE_PATH);
+}
+
+export async function get__FEATURE_PASCAL__<T = unknown>(
+  id: string
+): Promise<T> {
+  return get<T>(`${BASE_PATH}/${id}`);
+}
+
+export async function create__FEATURE_PASCAL__<TBody = unknown, TRes = unknown>(
+  payload: TBody
+): Promise<TRes> {
+  return post<TRes, TBody>(BASE_PATH, payload);
+}
+
+export async function update__FEATURE_PASCAL__<
+  TBody = unknown,
+  TRes = unknown
+>(id: string, payload: TBody): Promise<TRes> {
+  return put<TRes, TBody>(`${BASE_PATH}/${id}`, payload);
+}
+
+export async function delete__FEATURE_PASCAL__<TRes = void>(
+  id: string
+): Promise<TRes> {
+  return del<TRes>(`${BASE_PATH}/${id}`);
+}
+

package/templates/feature/components/feature.tsx

@@ -0,0 +1,7 @@
+"use client";
+import React from "react";
+type Props = {};
+
+export function __FEATURE_PASCAL__Feature({}: Props) {
+  return <div>__FEATURE_PASCAL__Feature</div>;
+}

package/templates/feature/hooks/useFeature.ts

@@ -0,0 +1,59 @@
+"use client";
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { featureKeys } from "../keys";
+import {
+  list__FEATURE_PASCAL__s,
+  create__FEATURE_PASCAL__,
+  update__FEATURE_PASCAL__,
+  delete__FEATURE_PASCAL__,
+} from "../api/featureApi";
+import type {
+  __FEATURE_PASCAL__CreatePayload,
+  __FEATURE_PASCAL__UpdatePayload,
+} from "../types/feature.types";
+
+export function use__FEATURE_PASCAL__List() {
+  return useQuery({
+    queryKey: featureKeys.lists(),
+    queryFn: () => list__FEATURE_PASCAL__s(),
+  });
+}
+
+export function useCreate__FEATURE_PASCAL__() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (payload: __FEATURE_PASCAL__CreatePayload) =>
+      create__FEATURE_PASCAL__(payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: featureKeys.lists() });
+    },
+  });
+}
+
+export function useUpdate__FEATURE_PASCAL__() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (params: {
+      id: string;
+      payload: __FEATURE_PASCAL__UpdatePayload;
+    }) => update__FEATURE_PASCAL__(params.id, params.payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: featureKeys.lists() });
+    },
+  });
+}
+
+export function useDelete__FEATURE_PASCAL__() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (id: string) => delete__FEATURE_PASCAL__(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: featureKeys.lists() });
+    },
+  });
+}
+

package/templates/feature/index.ts

@@ -0,0 +1,10 @@
+export { __FEATURE_PASCAL__Feature } from "./components/feature";
+export {
+  use__FEATURE_PASCAL__List,
+  useCreate__FEATURE_PASCAL__,
+  useUpdate__FEATURE_PASCAL__,
+  useDelete__FEATURE_PASCAL__,
+} from "./hooks/useFeature";
+export { featureKeys } from "./keys";
+export * as featureApi from "./api/featureApi";
+export * from "./types/feature.types";

package/templates/feature/keys.ts

@@ -0,0 +1,4 @@
+// Query keys for the __FEATURE_RAW__ feature
+import { createQueryKeys } from "@/lib/react-query/queryKeys";
+
+export const featureKeys = createQueryKeys("__FEATURE_RAW__");

package/templates/feature/tests/unit/features/feature/feature.barrel.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from "@jest/globals";
+
+describe("__FEATURE_RAW__ feature (barrel exports)", () => {
+  it("exports public API", async () => {
+    const feature = await import("@/features/__FEATURE_CAMEL__");
+
+    expect(feature).toHaveProperty("__FEATURE_PASCAL__Feature");
+    expect(typeof feature.__FEATURE_PASCAL__Feature).toBe("function");
+
+    expect(feature).toHaveProperty("featureKeys");
+    expect(feature.featureKeys).toBeTruthy();
+  });
+});
+

package/templates/feature/tests/unit/features/feature/featureApi.smoke.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "@jest/globals";
+import * as featureApi from "@/features/__FEATURE_CAMEL__/api/featureApi";
+
+describe("__FEATURE_CAMEL__Api (smoke)", () => {
+  it("exports expected functions", () => {
+    expect(typeof featureApi.list__FEATURE_PASCAL__s).toBe("function");
+    expect(typeof featureApi.get__FEATURE_PASCAL__).toBe("function");
+    expect(typeof featureApi.create__FEATURE_PASCAL__).toBe("function");
+    expect(typeof featureApi.update__FEATURE_PASCAL__).toBe("function");
+    expect(typeof featureApi.delete__FEATURE_PASCAL__).toBe("function");
+  });
+});
+

package/templates/feature/tests/unit/features/feature/featureKeys.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "@jest/globals";
+import { featureKeys } from "@/features/__FEATURE_CAMEL__/keys";
+
+describe("__FEATURE_RAW__ keys", () => {
+  it("builds stable query keys", () => {
+    expect(featureKeys.root).toEqual(["__FEATURE_RAW__"]);
+    expect(featureKeys.all()).toEqual(["__FEATURE_RAW__"]);
+    expect(featureKeys.lists()).toEqual(["__FEATURE_RAW__", "list"]);
+    expect(featureKeys.detail("1")).toEqual([
+      "__FEATURE_RAW__",
+      "detail",
+      "1",
+    ]);
+  });
+});
+

package/templates/feature/types/feature.types.ts

@@ -0,0 +1,9 @@
+export interface __FEATURE_PASCAL__Item {
+}
+
+export interface __FEATURE_PASCAL__CreatePayload {
+}
+
+export interface __FEATURE_PASCAL__UpdatePayload {
+}
+