adminforth 2.50.0-next.1 → 2.50.0-next.10

package/commands/createApp/templates/.agents/skills/adminforth/SKILL.md.hbs

@@ -0,0 +1,42 @@
+---
+name: adminforth
+description: "Use for general AdminForth app work: resources, index.ts, api.ts, schema.prisma, custom UI, Data API, adapters, plugins, and overall project structure. Use specialized skills for permissions, hooks, and custom Vue work."
+user-invocable: true
+---
+
+# AdminForth App Workflow
+
+## When to Use
+
+- Editing `index.ts`, `api.ts`, `resources/*.ts`, `custom/**`, environment files, or deployment files.
+- Adding a resource, menu item, custom page, component, custom API, plugin, or adapter.
+- Deciding whether logic belongs in resource config, the Data API, a custom Express route, or frontend customization.
+- Use `adminforth-permissions` when the task is mainly about access control.
+- Use `adminforth-hooks` when the task is mainly about lifecycle hooks.
+- Use `adminforth-custom-vue` when the task is mainly about components under `custom/`, field renderers, or page/login/global injections.
+
+## Project Map
+
+- `index.ts`: main AdminForth config, resource registration, menu, and server startup.
+- `api.ts`: custom Express endpoints. Prefer schema-aware handlers so request and response shapes stay explicit.
+- `resources/*.ts`: table or collection definitions, columns, labels, filters, and resource-level behavior.
+- `custom/`: Vue components, custom pages, injections, and static assets.
+{{#if prismaDbUrl}}- `schema.prisma`: optional schema and migration source when this app uses Prisma.{{/if}}
+- `.env.local` and `.env`: local config and secrets.
+
+## Recommended Workflow
+
+1. Change the database schema with Prisma or your own migration tool. AdminForth itself does not change the database schema for you.
+2. Add or update the matching resource in `resources/*.ts`.
+3. Register the resource and menu entry in `index.ts`.
+4. Prefer resource config for labels, field visibility, defaults, and validation before reaching for custom code.
+5. Use AdminForth Data API for simple CRUD, filtering, sorting, and counts. Use your own ORM or query builder for joins, aggregations, or more complex queries.
+6. Put custom business endpoints in `api.ts`.
+7. Put custom UI in `custom/`.
+
+## Commands
+
+- Install: `{{packageManager}} install`
+- Start local development: `{{packageManagerRun}} dev`
+{{#if prismaDbUrl}}- Apply local migrations: `{{packageManagerRun}} migrate:local`
+- Create a migration: `{{packageManagerRun}} makemigration{{packageManagerScriptArgSeparator}}--name <change-name>`{{/if}}

package/commands/createApp/templates/.agents/skills/adminforth-custom-vue/SKILL.md.hbs

@@ -0,0 +1,340 @@
+---
+name: adminforth-custom-vue
+description: "Use when implementing AdminForth custom Vue UI: field components, page injections, login or global injections, meta-driven component declarations, and frontend packages inside custom/."
+user-invocable: true
+---
+
+# AdminForth Custom Vue Workflow
+
+## When to Use
+
+- Editing files under `custom/`.
+- Adding custom field renderers or editors via `column.components`.
+- Adding resource page injections, login injections, or global layout injections.
+- Passing `meta` into reusable Vue components.
+- Installing frontend packages used only by custom AdminForth Vue code.
+
+## `custom/` Directory and `@@/`
+
+- `custom/` is the frontend workspace for AdminForth custom Vue code.
+- By default, `@@/Something.vue` means “resolve this path from `customComponentsDir` on the backend”, and `customComponentsDir` defaults to `./custom`.
+- Example: `@@/reports/OrdersHeader.vue` maps to `./custom/reports/OrdersHeader.vue`.
+- The same `@@/` prefix also works for assets and helper files that are bundled into the SPA.
+
+## Frontend Packages in `custom/`
+
+- Install frontend-only dependencies inside `custom/`, not in the app root.
+
+```bash
+cd custom
+{{packageManager}} install apexcharts vue3-apexcharts
+```
+
+- If `custom/package.json` does not exist yet, initialize the folder first.
+
+```bash
+cd custom
+{{packageManager}} init
+```
+
+## Organizing Components
+
+- You can freely create subfolders and split components into smaller children.
+- Example structure:
+
+```text
+custom/
+  reports/
+    OrdersTopPanel.vue
+    parts/
+      OrdersTotals.vue
+      OrdersFilters.vue
+```
+
+- Example parent component using subcomponents:
+
+```vue
+<template>
+  <section class="grid gap-4 md:grid-cols-2">
+    <OrdersTotals :record="record" />
+    <OrdersFilters :meta="meta" />
+  </section>
+</template>
+
+<script setup lang="ts">
+import OrdersTotals from './parts/OrdersTotals.vue';
+import OrdersFilters from './parts/OrdersFilters.vue';
+
+defineProps<{
+  record?: any;
+  meta?: any;
+}>();
+</script>
+```
+
+- In AdminForth config you still reference only the entry component:
+
+```ts
+beforeBreadcrumbs: '@@/reports/OrdersTopPanel.vue'
+```
+
+## Short vs Full Component Declaration
+
+- Short declaration is just a file string:
+
+```ts
+show: '@@/RoomsCell.vue'
+```
+
+- Full declaration lets you pass `meta`:
+
+```ts
+show: {
+  file: '@@/RoomsCell.vue',
+  meta: {
+    filler: '🟨',
+  },
+}
+```
+
+- Use full declaration when the same component should behave differently in different places.
+- `meta` is passed into the Vue component as a prop.
+- Common `meta` use cases are reusable display options, plugin settings, `thinEnoughToShrinkTable`, `afOrder`, or custom page layout flags.
+
+## Field Component Spots
+
+- `components.show`: custom value renderer on show page.
+- `components.showRow`: replaces the full show-table row.
+- `components.create`: custom editor on create page.
+- `components.edit`: custom editor on edit page.
+- `components.list`: custom value renderer in list cells.
+- `components.filter`: custom filter input.
+
+## Field Component Props and Emits
+
+- `show` and `list` components should expect `column`, `record`, `resource`, `adminUser`, and optional `meta`.
+- In practice, custom `edit` and `create` components receive `column`, `value`, `record`, `resource`, `adminUser`, `readonly`, and optional `meta`.
+- Custom `edit` and `create` components can emit:
+  - `update:value` to change the current field value.
+  - `update:recordFieldValue` to change another field in the same record.
+  - `update:inValidity` to report custom validation state.
+  - `update:emptiness` to report custom emptiness rules.
+- If you update hidden technical fields through `update:recordFieldValue`, the target column may need `allowModifyWhenNotShowInCreate` or `allowModifyWhenNotShowInEdit`.
+
+## Custom Edit Component Example
+
+```vue
+<template>
+  <div class="grid gap-2">
+    <Input
+      :model-value="localValue"
+      :readonly="readonly"
+      :placeholder="meta?.placeholder || column.label"
+      @update:model-value="onInput"
+    />
+
+    <p v-if="errorMessage" class="text-sm text-red-600">
+      {{ errorMessage }}
+    </p>
+
+    <p v-else-if="isEmpty" class="text-sm text-amber-600">
+      Value is currently empty
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import Input from '@/afcl/Input.vue';
+import type {
+  AdminForthResourceColumnCommon,
+  AdminForthResourceCommon,
+  AdminUser,
+} from '@/types/Common';
+
+const props = defineProps<{
+  column: AdminForthResourceColumnCommon;
+  value: string | null | undefined;
+  record: Record<string, any>;
+  meta?: { minLength?: number; placeholder?: string };
+  resource: AdminForthResourceCommon;
+  adminUser: AdminUser;
+  readonly: boolean;
+}>();
+
+const emit = defineEmits<{
+  (e: 'update:value', value: string): void;
+  (e: 'update:recordFieldValue', payload: { fieldName: string; fieldValue: any }): void;
+  (e: 'update:inValidity', value: string | false): void;
+  (e: 'update:emptiness', value: boolean): void;
+}>();
+
+const localValue = ref(props.value ?? '');
+const WHITESPACE_RE = /\s+/g;
+
+const isEmpty = computed(() => localValue.value.trim() === '');
+const errorMessage = computed(() => {
+  const minLength = props.meta?.minLength ?? 3;
+  if (isEmpty.value) {
+    return false;
+  }
+  return localValue.value.trim().length < minLength
+    ? `Minimum length is ${minLength}`
+    : false;
+});
+
+onMounted(syncState);
+
+function onInput(nextValue: string) {
+  localValue.value = nextValue;
+  emit('update:value', nextValue);
+  emit('update:recordFieldValue', {
+    fieldName: 'slug',
+    fieldValue: nextValue.toLowerCase().trim().replace(WHITESPACE_RE, '-'),
+  });
+  syncState();
+}
+
+function syncState() {
+  // for edit/create components where emptiness is not obvious (e.g. image was not uploaded), always emit emptiness when it change  
+  emit('update:emptiness', isEmpty.value);
+
+  // for custom validity (e.g. upload still in progress), emit error message or false for valid
+  emit('update:inValidity', errorMessage.value || false);
+}
+</script>
+```
+
+## Custom List and Show Example with `meta`
+
+```ts
+{
+  name: 'number_of_rooms',
+  components: {
+    show: {
+      file: '@@/RoomsCell.vue',
+      meta: { filler: '🟨', suffix: 'rooms' },
+    },
+    list: {
+      file: '@@/RoomsCell.vue',
+      meta: { filler: '🟦', suffix: 'r' },
+    },
+  },
+}
+```
+
+```vue
+<template>
+  <div class="flex items-center gap-2">
+    <span>
+      {{ meta?.filler?.repeat(record.number_of_rooms || 0) }}
+    </span>
+    <span>{{ record.number_of_rooms }} {{ meta?.suffix }}</span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type {
+  AdminForthResourceColumnCommon,
+  AdminForthResourceCommon,
+  AdminUser,
+} from '@/types/Common';
+
+defineProps<{
+  column: AdminForthResourceColumnCommon;
+  record: Record<string, any>;
+  meta?: { filler?: string; suffix?: string };
+  resource: AdminForthResourceCommon;
+  adminUser: AdminUser;
+}>();
+</script>
+```
+
+## Resource Page Injection Spots
+
+- `pageInjections.list.beforeBreadcrumbs`
+- `pageInjections.list.afterBreadcrumbs`
+- `pageInjections.list.beforeActionButtons`
+- `pageInjections.list.bottom`
+- `pageInjections.list.threeDotsDropdownItems`
+- `pageInjections.list.customActionIcons`
+- `pageInjections.list.customActionIconsThreeDotsMenuItems`
+- `pageInjections.list.tableBodyStart`
+- `pageInjections.list.tableRowReplace`
+- `pageInjections.show.beforeBreadcrumbs`
+- `pageInjections.show.afterBreadcrumbs`
+- `pageInjections.show.bottom`
+- `pageInjections.show.threeDotsDropdownItems`
+- `pageInjections.edit.beforeBreadcrumbs`
+- `pageInjections.edit.afterBreadcrumbs`
+- `pageInjections.edit.bottom`
+- `pageInjections.edit.threeDotsDropdownItems`
+- `pageInjections.create.beforeBreadcrumbs`
+- `pageInjections.create.afterBreadcrumbs`
+- `pageInjections.create.bottom`
+- `pageInjections.create.threeDotsDropdownItems`
+
+## Login and Global Injection Spots
+
+- `customization.loginPageInjections.panelHeader`
+- `customization.loginPageInjections.underInputs`
+- `customization.loginPageInjections.underLoginButton`
+- `customization.globalInjections.userMenu`
+- `customization.globalInjections.header`
+- `customization.globalInjections.sidebar`
+- `customization.globalInjections.sidebarTop`
+- `customization.globalInjections.everyPageBottom`
+
+## Top Injection Example
+
+```ts
+options: {
+  pageInjections: {
+    list: {
+      beforeBreadcrumbs: {
+        file: '@@/reports/OrdersTopPanel.vue',
+        meta: {
+          title: 'Orders overview',
+        },
+      },
+    },
+  },
+}
+```
+
+## List Injection Shrink Behavior
+
+- On list pages, AdminForth tries to keep the table itself scrollable when there are no large top or bottom injections.
+- That shrink behavior is affected by four list injection spots: `beforeBreadcrumbs`, `afterBreadcrumbs`, `beforeActionButtons`, and `bottom`.
+- If none of those four spots are used, the table tries to shrink into the viewport and vertical scrolling happens inside the table area.
+- If any of those spots are used, AdminForth assumes the page may now need extra vertical space, so the table stops shrinking and page scrolling moves to the document body instead.
+- If your injected panel is actually compact, set `meta.thinEnoughToShrinkTable: true` on that injection.
+- Important: every injection in those four spots must set `thinEnoughToShrinkTable: true`, otherwise the table will still stay in non-shrinking mode.
+
+```ts
+options: {
+  pageInjections: {
+    list: {
+      bottom: {
+        file: '@@/reports/OrdersSummary.vue',
+        meta: {
+          thinEnoughToShrinkTable: true,
+        },
+      },
+    },
+  },
+}
+```
+
+## Row-Level List Injection Notes
+
+- `tableBodyStart` renders extra `<tr>` rows near the start of the table body and receives `resource`, `adminUser`, and `meta`.
+- `tableRowReplace` replaces the default `<tr>` for each record and receives `record`, `resource`, `adminUser`, and `meta`.
+- `customActionIcons` and `customActionIconsThreeDotsMenuItems` are per-record spots and receive `record`, `resource`, `adminUser`, `meta`, and `updateRecords`.
+
+## Practical Rules
+
+- Prefer simple string declarations until you actually need `meta`.
+- Reuse one component with multiple full declarations instead of cloning similar files.
+- Keep page injections small unless the layout intentionally becomes page-scrolling.
+- Keep custom edit and create components explicit about validity and emptiness if the default input heuristics are not enough.

package/commands/createApp/templates/.agents/skills/adminforth-hooks/SKILL.md.hbs

@@ -0,0 +1,70 @@
+---
+name: adminforth-hooks
+description: "Use when implementing or changing AdminForth hooks: beforeDatasourceRequest, afterDatasourceResponse, beforeSave, afterSave, and source-aware show or edit flows."
+user-invocable: true
+---
+
+# AdminForth Hooks Workflow
+
+## When to Use
+
+- Editing `resource.hooks` in `resources/*.ts`.
+- Deciding which hook stage should own filtering, normalization, enrichment, validation, or side effects.
+- Handling the difference between show-page requests and edit-page initial load.
+
+## Hook Rules
+
+- Hooks execute on the backend during AdminForth request handling.
+- Keep hooks fast because every awaited operation delays the current request.
+- Return `{ ok: true }` to continue or `{ ok: false, error: 'message' }` to stop the flow.
+- A hook can be a single async function or an array of async functions.
+
+## Available Hooks
+
+- `show.beforeDatasourceRequest`
+- `show.afterDatasourceResponse`
+- `list.beforeDatasourceRequest`
+- `list.afterDatasourceResponse`
+- `create.beforeSave`
+- `create.afterSave`
+- `edit.beforeSave`
+- `edit.afterSave`
+- `delete.beforeSave`
+- `delete.afterSave`
+
+## Stage Selection
+
+- Use `beforeDatasourceRequest` for read-time scoping, filter changes, or blocking access before the datasource runs.
+- Use `afterDatasourceResponse` for reshaping or enriching records after the datasource returns them.
+- Use `beforeSave` for checks or data mutations that must happen before create, edit, or delete reaches the database.
+- Use `afterSave` only for post-write side effects such as logging, notifications, or sync work. Errors there do not roll back data that already reached the database.
+
+## Show and Edit Behavior
+
+- `show` hooks are also used when AdminForth loads initial data for the edit page.
+- Inside `show` hooks, inspect `query.source` on the hook params, not `extra.query`.
+- `query.source === 'show'` means the real show page.
+- `query.source === 'edit'` means the edit form initial-load flow.
+
+## Example
+
+```ts
+hooks: {
+	show: {
+		afterDatasourceResponse: async ({ query, response }) => {
+			if (query.source === 'edit') {
+				// runs only when AdminForth loads initial values for the edit page
+			} else if (query.source === 'show') {
+				// runs only on the real show page
+			}
+
+			return { ok: true };
+		},
+	},
+}
+```
+
+## Choosing Hooks vs Permissions
+
+- Prefer `adminforth-permissions` for straightforward role-based access control.
+- Use hooks when the rule depends on specific record values, incoming filters, mutations, or request lifecycle timing.

package/commands/createApp/templates/.agents/skills/adminforth-permissions/SKILL.md.hbs

@@ -0,0 +1,59 @@
+---
+name: adminforth-permissions
+description: "Use when implementing or changing AdminForth access control: allowedActions, showIn callbacks, menu visibility, per-record restrictions, and permission-aware resource behavior."
+user-invocable: true
+---
+
+# AdminForth Permissions Workflow
+
+## When to Use
+
+- Editing `options.allowedActions`, column `showIn.*` callbacks, menu visibility, or other permission-sensitive resource behavior.
+- Deciding whether a rule belongs in `allowedActions`, `showIn[x]`, or a hook that blocks access for specific records.
+- Explaining why hiding a menu item is not the same as real authorization.
+
+## Permission Model
+
+- `allowedActions` is the real per-resource permission layer for `list`, `show`, `create`, `edit`, `delete`, and `filter`.
+- `showIn[x]` is the real per-column and per-page-flow control for whether a field is accessible in a given UI flow.
+- Menu visibility is UX only. Hiding a resource from the menu does not block direct URL access or API access.
+- For per-record restrictions, use hooks that run before datasource access or before save and return `{ ok: false, error: 'message' }`.
+
+## Allowed Actions Rules
+
+- `allowedActions` can be static booleans or async functions.
+- The callback receives `adminUser`, `resource`, `meta`, `source`, and `adminforth`.
+- `source` tells you why the permission is being checked. Available values are `displayButtons`, `listRequest`, `showRequest`, `editLoadRequest`, `editRequest`, `createRequest`, `deleteRequest`, `bulkActionRequest`, and `customActionRequest`.
+- `allowedActions` is evaluated for both UI rendering and real requests, so keep it fast and avoid unnecessary database work.
+- Use `source === ActionCheckSource.DisplayButtons` only when you intentionally want different UI visibility from actual request authorization.
+
+## Example
+
+```ts
+import { ActionCheckSource } from 'adminforth';
+
+{
+	resourceId: 'orders',
+	options: {
+		allowedActions: {
+			list: ({ adminUser }) => adminUser.dbUser.role !== 'suspended',
+			delete: ({ adminUser, source }) => {
+				// `source` tells you why AdminForth is checking permission.
+				// This keeps the delete button visible, but blocks the real delete
+				// unless the request is made by a superadmin.
+				if (source === ActionCheckSource.DisplayButtons) {
+					return true;
+				}
+
+				return adminUser.dbUser.role === 'superadmin';
+			},
+		},
+	},
+}
+```
+
+## Choosing the Right Layer
+
+- Use `allowedActions` for coarse resource-level permissions such as role-based create, edit, delete, or list access.
+- Use `showIn[x]` when a field should be visible or editable only in specific flows or for specific admins.
+- Use hooks when access depends on actual record values, request filters, or lifecycle context.

package/commands/createApp/templates/AGENTS.md.hbs

@@ -0,0 +1,71 @@
+# AdminForth App Guide
+
+## Package manager
+
+This scaffold was generated with `{{packageManager}}`. Use `{{packageManager}}` commands in this project unless you intentionally migrate the tooling.
+
+## Project map
+
+- `index.ts` is the main AdminForth configuration and server entrypoint.
+- `api.ts` is for custom Express APIs and request/response schemas.
+- `resources/*.ts` defines resources, columns, labels, permissions, hooks, and display behavior.
+- `custom/` is for custom Vue components, pages, injections, and static assets.
+{{#if prismaDbUrl}}- `schema.prisma` is the schema and migration source if you use Prisma for this app.{{/if}}
+- `.env.local` stores local non-sensitive defaults. `.env` stores secrets. In production prefer real environment variables or a secret manager.
+
+## Docs sources for agents
+
+- Use `https://adminforth.dev/llms.txt` for quick navigation across the AdminForth docs corpus.
+- Use `https://adminforth.dev/llms-full.txt` (`llms full`) for the full single-file AdminForth reference.
+- Prefer these sources before broad web search when the task is mainly about AdminForth APIs, plugins, adapters, or customization.
+
+## Common commands
+
+- Install dependencies: `{{packageManager}} install`
+- Start the app locally: `{{packageManagerRun}} dev`
+{{#if prismaDbUrl}}- Apply local migrations: `{{packageManagerRun}} migrate:local`
+- Create a new migration and apply it locally: `{{packageManagerRun}} makemigration{{packageManagerScriptArgSeparator}}--name <change-name>`{{/if}}
+
+## AdminForth workflow
+
+- AdminForth connects to existing database and gives a back-office over the data (CRUD, filtering, sorting, etc).
+- One table or collection maps to one resource. 
+- Resource config database type agnostic (same for all db types).
+- Add new resources in `resources/`, register them in `index.ts`, and add menu entries if you want them visible in the sidebar.
+- Resource config should mandatory list all column names which AdminFramework should be aware of, column name should match the name in the database table/collection.
+- For relational schema-based dbs types of columns in resource are optional and used for overriding where possible, however AdminForth by default fetches physycal types and manual specification is not required. 
+- For NoSQL or schemaless dbs types of columns in resource are required for AdminForth to work.
+- AdminForth does not manage database schema. By default project ships Prisma but developer can use own migration tool, and update only through `resources/*.ts` and `index.ts`.
+- Always create `recordLabel` to change on UI how one record is represented across the app. Try to include the most identifying information but human-readable in the label but keep it short for readability (avoid IDs if possible).
+- Use  `fillOnCreate` to fill with default values on record creation on backend. Avoid showIn.create=true + fillOnCreate for the same field.
+- Use `suggestOnCreate` to prefill input with a suggested value on the frontend.
+- Use `enum`, `minLength`, `maxLength` in column config to enforce validation rules.
+
+- Use AdminForth Data API for simple CRUD, filtering, sorting, and counts. For joins, aggregations, or heavier queries, use custom ORM or query builder.
+- Use `api.ts` for custom business endpoints that do not fit standard resource CRUD.
+- Use `custom/` for custom pages, field rendering, injections, and other Vue-side customization.
+
+### Access control
+
+- Keep access control explicit and backend-enforced. Menu visibility is only UX and is not a permission boundary.
+- For permission-specific implementation details, examples, and routing between `allowedActions`, `showIn[x]`, and hooks, use the `adminforth-permissions` skill.
+
+### Hooks
+
+- Hooks run on the backend as part of AdminForth request flows, so keep them focused and fast.
+- For hook stage selection, show-vs-edit behavior, and implementation examples, use the `adminforth-hooks` skill.
+
+## Engineering conventions
+
+- Trust typed internal contracts. Do not add duplicate validation for values already guaranteed by schema, types, or backend responses.
+- Validate once at the boundary, not repeatedly in downstream consumers.
+- Prefer small explicit helpers and named constants over speculative fallback logic.
+- Extract reusable or non-trivial regexes into named constants instead of scattering inline regexes through business logic.
+- Keep changes minimal, DRY, and YAGNI.
+
+## Before you change the app
+
+- If you add a new resource, register it in `index.ts` and add it to the menu if needed.
+{{#if prismaDbUrl}}- If you change `schema.prisma`, create and apply a migration locally before testing the UI.{{/if}}
+- If you add custom frontend code under `custom/`, install any extra frontend packages in `custom/package.json`.
+- Default local login is `adminforth` / `adminforth` unless you changed the seeded admin user.

package/commands/createApp/templates/CLAUDE.md.hbs

@@ -0,0 +1,5 @@
+@AGENTS.md
+
+# Claude-specific notes
+
+When working with this project, follow the AdminForth conventions from AGENTS.md.

package/commands/createApp/templates/Dockerfile.hbs

@@ -1,19 +1,8 @@
 
-{{#unless useNpm}}
-FROM devforth/node20-pnpm:latest
+FROM {{dockerBaseImage}}
 WORKDIR /code/
-ADD package.json pnpm-lock.yaml pnpm-workspace.yaml /code/
-RUN pnpm i  
+ADD package.json {{dockerAdditionalManifestFiles}} /code/
+RUN {{packageManager}} {{dockerPackageInstallSubcommand}}  
 ADD . /code/
-RUN pnpm exec adminforth bundle
-CMD ["sh", "-c", "pnpm migrate:prod && pnpm prod"]
-{{/unless}}
-{{#if useNpm}}
-FROM node:{{nodeMajor}}-slim
-WORKDIR /code/
-ADD package.json package-lock.json /code/
-RUN npm ci  
-ADD . /code/
-RUN npx adminforth bundle
-CMD ["sh", "-c", "npm run migrate:prod && npm run prod"]
-{{/if}}
+RUN {{packageManagerExec}} adminforth bundle
+CMD ["sh", "-c", "{{packageManagerRun}} migrate:prod && {{packageManagerRun}} prod"]

package/commands/createApp/templates/package.json.hbs

@@ -8,26 +8,14 @@
   "license": "ISC",
   "description": "",
   "scripts": {
-    {{#unless useNpm}}
-    "dev": "pnpm _env:dev tsx watch index.ts",
-    "prod": "pnpm _env:prod tsx index.ts",
-    "start": "pnpm dev",
-    "makemigration": "pnpm _env:dev npx --yes prisma migrate dev --create-only",
-    "migrate:local": "pnpm _env:dev npx --yes prisma migrate deploy",
-    "migrate:prod": "pnpm _env:prod npx --yes prisma migrate deploy",
+    "dev": "{{packageManagerEnvDev}} tsx watch index.ts",
+    "prod": "{{packageManagerEnvProd}} tsx index.ts",
+    "start": "{{packageManagerRun}} dev",
+    "makemigration": "{{packageManagerEnvDev}} npx --yes prisma migrate dev --create-only",
+    "migrate:local": "{{packageManagerEnvDev}} npx --yes prisma migrate deploy",
+    "migrate:prod": "{{packageManagerEnvProd}} npx --yes prisma migrate deploy",
     "_env:dev": "dotenvx run -f .env -f .env.local --",
     "_env:prod": "dotenvx run -f .env.prod --"
-    {{/unless}}
-    {{#if useNpm}}
-      "dev": "npm run _env:dev -- tsx watch index.ts",
-      "prod": "npm run _env:prod -- tsx index.ts",
-      "start": "npm run dev",
-      "makemigration": "npm run _env:dev -- npx --yes prisma migrate dev --create-only",
-      "migrate:local": "npm run _env:dev -- npx --yes prisma migrate deploy",
-      "migrate:prod": "npm run _env:prod -- npx --yes prisma migrate deploy",
-      "_env:dev": "dotenvx run -f .env -f .env.local --",
-      "_env:prod": "dotenvx run -f .env.prod --"
-    {{/if}}
   },
   "engines": {
     "node": ">=20"