@akanjs/cli 0.9.48 → 0.9.50

package/esm/src/guidelines/modelService/modelService.instruction.md

@@ -23,7 +23,6 @@ Akan.js services typically extend base service classes provided by the framework
 Most services extend `DbService` to work with MongoDB models:
 
 ```typescript
-@Service("ProductService")
 export class ProductService extends DbService(db.productDb) {
   // Service methods here
 }
@@ -31,13 +30,12 @@ export class ProductService extends DbService(db.productDb) {
 
 The `DbService` function automatically injects the database model and provides numerous convenience methods for CRUD operations.
 
-### LogService
+### serve
 
 For utility services that don't directly work with a database model:
 
 ```typescript
-@Service("SecurityService")
-export class SecurityService extends LogService("SecurityService") {
+export class SecurityService extends serve("security" as const) {
   // Utility methods here
 }
 ```
@@ -51,7 +49,7 @@ For specific domain services with shared functionality:
 export const LibService = MixSrvs(SharedService, PlatformService, SocialService);
 
 // In another service
-@Service("CustomService")
+
 export class CustomService extends LibService {
   // Custom methods here
 }
@@ -59,20 +57,6 @@ export class CustomService extends LibService {
 
 ## Core Decorators
 
-### @Service Decorator
-
-Declares a class as an injectable NestJS service with additional configuration options:
-
-```typescript
-@Service("UserService", {
-  enabled: true, // Enable/disable service dynamically
-  serverMode: "federation", // "federation", "batch", or not specified
-})
-export class UserService extends DbService(db.userDb) {
-  // Service implementation
-}
-```
-
 Options:
 
 - `enabled`: Boolean flag to conditionally disable a service (default: true)
@@ -263,7 +247,6 @@ async _postRemove(doc: Product): Promise<Product> {
 Services often work together to implement complex operations:
 
 ```typescript
-@Service("OrderService")
 export class OrderService extends DbService(db.orderDb) {
   @Srv() productService: ProductService;
   @Srv() userService: UserService;
@@ -322,7 +305,6 @@ export class OrderService extends DbService(db.orderDb) {
 For real-time features:
 
 ```typescript
-@Service("ChatService")
 export class ChatService extends DbService(db.chatDb) {
   @Websocket()
   websocket: Websocket<ChatSignal>;
@@ -354,8 +336,7 @@ export class ChatService extends DbService(db.chatDb) {
 For background processing:
 
 ```typescript
-@Service("EmailService")
-export class EmailService extends LogService("EmailService") {
+export class EmailService extends serve("email" as const) {
   @Queue()
   emailQueue: Queue<EmailSignal>;
   @Use()
@@ -441,7 +422,7 @@ Services should not maintain internal state between requests:
 
 ```typescript
 // BAD - maintains state in the service
-@Service("CounterService")
+
 class CounterService {
   private count = 0; // This state is lost on server restart
 
@@ -454,7 +435,7 @@ class CounterService {
 }
 
 // GOOD - uses database for state
-@Service("CounterService")
+
 class CounterService extends DbService(db.counterDb) {
   async increment(counterId: string) {
     const counter = await this.getCounter(counterId);
@@ -474,7 +455,7 @@ Each service should focus on a specific domain:
 
 ```typescript
 // BAD - mixing concerns
-@Service("UserService")
+
 class UserService extends DbService(db.userDb) {
   async createUser(data) {
     // User creation logic
@@ -490,7 +471,7 @@ class UserService extends DbService(db.userDb) {
 }
 
 // GOOD - separate services
-@Service("UserService")
+
 class UserService extends DbService(db.userDb) {
   @Srv() emailService: EmailService;
   @Srv() paymentService: PaymentService;
@@ -500,14 +481,12 @@ class UserService extends DbService(db.userDb) {
   }
 }
 
-@Service("EmailService")
-class EmailService extends LogService("EmailService") {
+class EmailService extends serve("email" as const) {
   async sendEmail(userId, subject, content) {
     // Email sending logic
   }
 }
 
-@Service("PaymentService")
 class PaymentService extends DbService(db.paymentDb) {
   async processPayment(userId, amount) {
     // Payment processing logic
@@ -546,13 +525,12 @@ Inject other services using decorators, not direct imports:
 // BAD - direct import
 import { UserService } from "../user/user.service";
 
-@Service("OrderService")
 class OrderService extends DbService(db.orderDb) {
   private userService = new UserService(); // Hard-coded dependency
 }
 
 // GOOD - dependency injection
-@Service("OrderService")
+
 class OrderService extends DbService(db.orderDb) {
   @Srv() userService: UserService; // Injected dependency
 }
@@ -563,7 +541,6 @@ class OrderService extends DbService(db.orderDb) {
 Use the built-in logger for consistent logging:
 
 ```typescript
-@Service("PaymentService")
 class PaymentService extends DbService(db.paymentDb) {
   async processPayment(orderId: string, amount: number) {
     this.logger.log(`Processing payment of ${amount} for order ${orderId}`);
@@ -581,20 +558,6 @@ class PaymentService extends DbService(db.paymentDb) {
 }
 ```
 
-## Integration with NestJS
-
-Akan.js services are built on top of NestJS's dependency injection system. The `@Service` decorator builds on top of NestJS's `@Injectable()`:
-
-```typescript
-// Behind the scenes, @Service does this:
-@Injectable()
-export class UserService {
-  // ...
-}
-```
-
-This allows Akan.js services to be used within NestJS modules, controllers, and resolvers.
-
 ## Complete Example
 
 Here's a complete example of a service implementation:
@@ -602,7 +565,7 @@ Here's a complete example of a service implementation:
 ```typescript
 import { Dayjs } from "@akanjs/base";
 import { Cron } from "@akanjs/nest";
-import { DbService, Service, Srv, Use } from "@akanjs/service";
+import { DbService, Srv, Use } from "@akanjs/service";
 import type { EmailApi } from "@util/nest";
 
 import * as cnst from "../cnst";
@@ -610,7 +573,6 @@ import * as db from "../db";
 import { Revert } from "../dict";
 import type * as srv from "../srv";
 
-@Service("OrderService")
 export class OrderService extends DbService(db.orderDb) {
   @Srv() userService: srv.UserService;
   @Srv() productService: srv.ProductService;
@@ -704,31 +666,6 @@ export class OrderService extends DbService(db.orderDb) {
 
 ## Troubleshooting
 
-### Service Not Being Injected
-
-If a service isn't being injected correctly:
-
-1. Ensure the service name matches:
-
-   ```typescript
-   @Service("UserService")  // This name must match
-   export class UserService extends DbService(db.userDb) {}
-
-   @Srv("UserService")  // Or this must match if using explicit name
-   userService: UserService;
-   ```
-
-2. Check if the service is enabled in the current environment:
-
-   ```typescript
-   @Service("UserService", { enabled: process.env.ENABLE_USER_SERVICE === 'true' })
-   ```
-
-3. Verify server mode restrictions:
-   ```typescript
-   @Service("CleanupService", { serverMode: "batch" })  // Only runs in batch mode
-   ```
-
 ### Database Operations Failing
 
 1. Check model definition and schema:
@@ -763,7 +700,7 @@ Model services in Akan.js are powerful components that encapsulate business logi
 Key takeaways:
 
 - Services should be stateless, with persistent state managed in the database
-- Use the appropriate decorator (@Service, @Srv, @Use, etc.) for dependency injection
+- Use the appropriate decorator (@Srv, @Use, etc.) for dependency injection
 - Implement lifecycle hooks for proper resource management
 - Use scheduled tasks for recurring operations
 - Follow single responsibility principle

package/esm/src/guidelines/modelSignal/modelSignal.generate.json

@@ -176,7 +176,6 @@
     "contents": [
       "Purpose and role of model.signal.ts files",
       "Signal class structure and core components",
-      "@Signal decorator and Signal class definition",
       "DbSignal and other higher-order functions",
       "Endpoint decorators (@Query, @Mutation, @Message, @Process, @Pubsub)",
       "Parameter decorators (@Arg.Query, @Arg.Param, @Arg.Body, @Self, etc.)",

package/esm/src/guidelines/modelSignal/modelSignal.instruction.md

@@ -26,7 +26,6 @@ import { Arg, DbSignal, Mutation, Query, resolve, Self, Signal } from "@akanjs/s
 import * as cnst from "../cnst";
 import type * as db from "../db";
 
-@Signal(() => cnst.ModelName)
 export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.User },
 }) {
@@ -36,36 +35,7 @@ export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, cnst.Srvs, {
 
 Key components:
 
-- `@Signal()` decorator defines this class as a signal provider
-- `DbSignal()` higher-order function provides standard CRUD operations
-- `guards` option configures default access control for CRUD operations
-- Service references are injected from `Srvs` imported from cnst.ts
-
-## Decorator Reference
-
-### 1. @Query Decorator
-
-Used for read-only operations with access control levels:
-
-```typescript
-@Query.Public(() => [cnst.Product])  // Public access, returns array of Products
-async productListInFeatured(
-  @Arg.Query("skip", () => Int, { nullable: true }) skip: number | null,
-  @Arg.Query("limit", () => Int, { nullable: true }) limit: number | null,
-  @Arg.Query("sort", () => String, { nullable: true }) sort: SortOf<cnst.ProductFilter> | null
-) {
-  const products = await this.productService.listFeatured({ skip, limit, sort });
-  return resolve<cnst.Product[]>(products);  // Type-safe resolution
-}
-```
-
-Access control levels:
-
-- `Query.Public` - Available to unauthenticated users
-- `Query.User` - Requires user authentication
-- `Query.Admin` - Requires admin access
-- `Query.SuperAdmin` - Requires super admin access
-- `Query.Every` - Available to all authenticated users (any role)
+- `
 
 ### 2. @Mutation Decorator
 
@@ -169,7 +139,7 @@ The slice pattern standardizes data access with consistent naming and pagination
 async chatRoomListInSelf(  // listIn<SliceName> pattern
   @Arg.Query("skip", () => Int, { nullable: true }) skip: number | null,
   @Arg.Query("limit", () => Int, { nullable: true }) limit: number | null,
-  @Arg.Query("sort", () => String, { nullable: true }) sort: SortOf<cnst.ChatRoomFilter> | null,
+  @Arg.Query("sort", () => String, { nullable: true }) sort: SortOf<db.ChatRoomFilter> | null,
   @Self() self: Self
 ) {
   const chatRooms = await this.chatRoomService.listInUser(self.id, { skip, limit, sort });
@@ -288,7 +258,6 @@ function ChatRoom({ roomId }) {
 DbSignal creates standard operations that you don't need to implement:
 
 ```typescript
-@Signal(() => cnst.Board)
 export class BoardSignal extends DbSignal(cnst.boardCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.Admin },
 }) {
@@ -408,7 +377,6 @@ async getProjectDetails(
 ### Basic CRUD Signal with DbSignal
 
 ```typescript
-@Signal(() => cnst.Product)
 export class ProductSignal extends DbSignal(cnst.productCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.Admin },
 }) {
@@ -436,7 +404,6 @@ export class ProductSignal extends DbSignal(cnst.productCnst, cnst.Srvs, {
 ### Real-Time Chat Signal
 
 ```typescript
-@Signal(() => cnst.Chat)
 export class ChatSignal {
   @Mutation.User(() => cnst.Chat)
   async sendChat(
@@ -464,7 +431,6 @@ export class ChatSignal {
 ### Background Processing Signal
 
 ```typescript
-@Signal(() => cnst.Report)
 export class ReportSignal {
   @Mutation.Admin(() => cnst.Report)
   async generateReport(
@@ -543,7 +509,6 @@ export function SelfSlice<T>(returnType: () => T) {
 ### Signal Integration with External APIs
 
 ```typescript
-@Signal(() => cnst.ExternalData)
 export class ExternalApiSignal {
   @Query.Public(() => cnst.WeatherData)
   async getWeatherData(@Arg.Query("location", () => String) location: string) {
@@ -564,7 +529,6 @@ export class ExternalApiSignal {
 Signals can implement caching for performance:
 
 ```typescript
-@Signal(() => cnst.Product)
 export class ProductSignal extends DbSignal(cnst.productCnst, Srvs) {
   @Query.Public(() => cnst.Product)
   async getProduct(@Arg.Param("productId", () => ID) productId: string) {

package/esm/src/guidelines/modelStore/modelStore.instruction.md

@@ -37,7 +37,6 @@ import { stateOf, Store } from "@akanjs/store";
 import * as cnst from "../cnst";
 import { fetch } from "../sig";
 
-@Store(() => cnst.Product)
 export class ProductStore extends stateOf(fetch.productGql, {
   // Custom state properties
   featuredProducts: [] as cnst.LightProduct[],
@@ -359,7 +358,7 @@ For complex applications, compose multiple stores:
 // In store.ts
 export class RootStore extends MixStore(ProductStore, CategoryStore, VendorStore, CartStore) {}
 
-export const store = rootStoreOf(RootStore);
+export const storeRoot = rootStoreOf(RootStore);
 ```
 
 ### Cross-Store Operations
@@ -489,7 +488,6 @@ import * as cnst from "../cnst";
 import { fetch } from "../sig";
 import { msg } from "../msg";
 
-@Store(() => cnst.Product)
 export class ProductStore extends stateOf(fetch.productGql, {
   // UI State
   productViewMode: "grid" as "grid" | "list",

package/esm/src/guidelines/modelTemplate/modelTemplate.instruction.md

@@ -40,7 +40,7 @@ Model.Template.tsx files are client-side React components that define the form s
 "use client";
 import { Field } from "@shared/ui";
 import { st } from "@[project]/client";
-import { usePage } from "@[project]/lib/usePage";
+import { usePage } from "@[project]/lib/useClient";
 
 export const General = ({ id }: { id?: string }) => {
   const form = st.use.[model]Form();
@@ -466,7 +466,7 @@ const DockerRegistry = ({ value, onChange }) => (
 
 ```tsx
 // Model.constant.ts
-@Model.Input("ProjectInput")
+
 export class ProjectInput {
   @Field.Prop(() => String)
   name: string;

package/esm/src/guidelines/modelUnit/modelUnit.instruction.md

@@ -148,7 +148,7 @@ Model Units work with LightModel types defined in constant files:
 
 ```tsx
 // In your constant.ts file
-@Model.Light("LightProduct")
+
 export class LightProduct extends via(ProductObject, ["name", "price", "sku", "inStock"] as const) {
   get displayPrice() {
     return `${this.price.toLocaleString()} KRW`;
@@ -503,7 +503,7 @@ Type error: Property 'description' does not exist on type 'LightProduct'
 
 ```tsx
 // In constant.ts
-@Model.Light("LightProduct")
+
 export class LightProduct extends via(ProductObject, ["name", "price", "sku"] as const) {
   // Only these fields are guaranteed to be available
 }

package/esm/src/guidelines/scalarConstant/scalarConstant.instruction.md

@@ -41,7 +41,7 @@ export const Status = enumOf(["active", "inactive"] as const);
 export type Status = enumOf<typeof Status>;
 
 // 3. Scalar model class (SINGLE CLASS PER FILE)
-@Model.Scalar("ScalarName") // Must match class name
+// Must match class name
 export class ScalarName {
   // Field definitions
   @Field.Prop(() => FieldType, { ...options })
@@ -74,7 +74,7 @@ import { OtherScalar } from "../other-scalar/other-scalar.constant";
 ### Basic Structure
 
 ```typescript
-@Model.Scalar("ScalarName") // String must match class name
+// String must match class name
 export class ScalarName {
   // Field definitions go here
 }
@@ -207,7 +207,6 @@ status: Status;
 Scalar classes can include static methods for common operations on the scalar type:
 
 ```typescript
-@Model.Scalar("Coordinate")
 export class Coordinate {
   @Field.Prop(() => [Float], { default: [0, 0] })
   coordinates: number[];
@@ -305,8 +304,8 @@ export type Status = enumOf<typeof Status>;
 
 ```typescript
 // ❌ Wrong (violates single-responsibility)
-@Model.Scalar("Address") class Address { ... }
-@Model.Scalar("User") class User { ... }
+ class Address { ... }
+ class User { ... }
 
 // ✅ Correct (separate files)
 // address.constant.ts
@@ -339,7 +338,7 @@ createdAt: Dayjs;
 export class GeoLocation { ... }
 
 // ✅ Correct
-@Model.Scalar("GeoLocation")
+
 export class GeoLocation { ... }
 ```
 
@@ -352,7 +351,6 @@ export class GeoLocation { ... }
 import { Float } from "@akanjs/base";
 import { Field, Model } from "@akanjs/constant";
 
-@Model.Scalar("Amount")
 export class Amount {
   @Field.Prop(() => Float, { min: 0, default: 0 })
   value: number;
@@ -373,7 +371,6 @@ import { Field, Model } from "@akanjs/constant";
 export const AccuracyLevel = enumOf(["low", "medium", "high"] as const);
 export type AccuracyLevel = enumOf<typeof AccuracyLevel>;
 
-@Model.Scalar("GeoLocation")
 export class GeoLocation {
   @Field.Prop(() => Float, {
     min: -90,
@@ -418,7 +415,6 @@ import { Int, Float } from "@akanjs/base";
 import { Field, Model } from "@akanjs/constant";
 import { Dimension } from "../dimension/dimension.constant";
 
-@Model.Scalar("ProductSpec")
 export class ProductSpec {
   @Field.Prop(() => String)
   sku: string;
@@ -450,7 +446,6 @@ export class ProductSpec {
 import { Float } from "@akanjs/base";
 import { Field, Model } from "@akanjs/constant";
 
-@Model.Scalar("Coordinate")
 export class Coordinate {
   @Field.Prop(() => [Float], { default: [0, 0], example: [127.114367, 37.497114] })
   coordinates: number[];
@@ -477,7 +472,7 @@ export class Coordinate {
 1. **Location**: `__scalar/<camelCase>/<camelCase>.constant.ts`
 2. **Structure**: Single `@Model.Scalar` class per file
 3. **Naming**: Class name = PascalCase directory name
-4. **Decorator**: `@Model.Scalar("ClassName")` with exact class name match
+4. **Decorator**: `` with exact class name match
 5. **Enum Values**: Always camelCase (`active`, not `ACTIVE`)
 6. **Fields**: Use `@Field.Prop` with arrow function types
 7. **Arrays**: Wrap in `[]` (e.g., `[Int]`)

package/esm/src/templates/__scalar/__model__/__model__.constant.js

@@ -1,13 +1,12 @@
 // pkgs/@akanjs/cli/src/templates/__scalar/__model__/__model__.constant.ts
 function getContent(scanInfo, dict) {
   return `
-import { Field, Model } from "@akanjs/constant";
+import { via } from "@akanjs/constant";
 
-@Model.Scalar("${dict.Model}")
-export class ${dict.Model} {
-  @Field.Prop(() => String)
-  field: string;
-}
+
+export class ${dict.Model} extends via((field) => ({
+  field: field(String),
+})) {}
 `;
 }
 export {

package/esm/src/templates/__scalar/__model__/__model__.dictionary.js

@@ -5,7 +5,7 @@ import { ModelDictionary } from "@akanjs/dictionary";
 
 import type { ${dict.Model} } from "./${dict.model}.constant";
 
-const modelDictionary = {
+export const modelDictionary = {
   modelName: ["${dict.Model}", "${dict.Model}"],
   modelDesc: ["${dict.Model}", "${dict.Model}"],
 

package/esm/src/templates/app/app/[lang]/layout.js

@@ -20,7 +20,6 @@ export default function Layout({ children, params }: RootLayoutProps) {
       head={<link rel="icon" href="/favicon.ico" />}
       // className="bg-base-100"
       env={env}
-      fetch={fetch}
     >
       {children}
     </System.Provider>

package/esm/src/templates/app/app/csr.js

@@ -5,7 +5,9 @@ function getContent(scanInfo, dict) {
     content: `
 import { bootCsr } from "@akanjs/next";
 
-void bootCsr(import.meta.glob("./**/*.tsx"));
+import { registerClient } from "../client";
+
+void bootCsr(import.meta.glob("./**/*.tsx"), registerClient);
   `
   };
 }

package/esm/src/templates/app/lib/___appName__/__appName__.dictionary.js

@@ -6,7 +6,7 @@ import type { ${dict.AppName}Signal } from "./${dict.appName}.signal";
 
 const dictionary = {} as const;
 
-const signalDictionary = {} satisfies SignalDictionary<${dict.AppName}Signal>;
+export const signalDictionary = {} satisfies SignalDictionary<${dict.AppName}Signal>;
 
 export const ${dict.appName}Dictionary = { ...dictionary, ...signalDictionary };
   `;

package/esm/src/templates/app/lib/___appName__/__appName__.service.js

@@ -1,10 +1,9 @@
 // pkgs/@akanjs/cli/src/templates/app/lib/___appName__/__appName__.service.ts
 function getContent(scanInfo, dict) {
   return `
-import { LogService, Service } from "@akanjs/service";
+import { serve } from "@akanjs/service";
 
-@Service("${dict.appName}Service", { serverMode: "batch" })
-export class ${dict.AppName}Service extends LogService("${dict.appName}Service") {}
+export class ${dict.AppName}Service extends serve("${dict.appName}" as const, { serverMode: "batch" }) {}
 `;
 }
 export {

package/esm/src/templates/app/lib/___appName__/__appName__.signal.js

@@ -1,12 +1,11 @@
 // pkgs/@akanjs/cli/src/templates/app/lib/___appName__/__appName__.signal.ts
 function getContent(scanInfo, dict) {
   return `
-import { LogSignal, Signal } from "@akanjs/signal";
+import { signal } from "@akanjs/signal";
 
 import * as cnst from "../cnst";
 
-@Signal({ name: "${dict.AppName}" })
-export class ${dict.AppName}Signal extends LogSignal(cnst.Srvs) {}
+export class ${dict.AppName}Signal extends signal("${dict.AppName}" as const, cnst.Srvs) {}
   `;
 }
 export {

package/esm/src/templates/app/lib/___appName__/__appName__.store.js

@@ -1,10 +1,9 @@
 // pkgs/@akanjs/cli/src/templates/app/lib/___appName__/__appName__.store.ts
 function getContent(scanInfo, dict) {
   return `
-import { scalarStateOf, Store } from "@akanjs/store";
+import { store } from "@akanjs/store";
 
-@Store({ name: "${dict.appName}" })
-export class ${dict.AppName}Store extends scalarStateOf("${dict.appName}" as const, {
+export class ${dict.AppName}Store extends store("${dict.appName}" as const, {
   // state
 }) {
   // action

package/esm/src/templates/client.js

@@ -13,10 +13,10 @@ function getContent(scanInfo, dict = {}) {
     ([_, fileTypes]) => fileTypes.has("template") || fileTypes.has("unit") || fileTypes.has("util") || fileTypes.has("view") || fileTypes.has("zone")
   ).map(([key]) => key);
   return `
-export { Revert, msg, usePage } from "./lib/usePage";
-export { st, store } from "./lib/st";
-export { fetch } from "./lib/sig";
-export * as cnst from "./lib/cnst"
+export * as cnst from "./lib/cnst";
+export { msg, Revert, usePage, fetch, sig, registerClient } from "./lib/useClient";
+export { st, RootStore } from "./lib/st";
+export * as store from "./lib/st";
 ${scalarModules.map((module) => `export { ${capitalize(module)} } from "./lib/__scalar/${module}";`).join("\n")}
 ${serviceModules.map((module) => `export { ${capitalize(module)} } from "./lib/_${module}";`).join("\n")}
 ${databaseModules.map((module) => `export { ${capitalize(module)} } from "./lib/${module}";`).join("\n")}

package/esm/src/templates/crudPages/[__model__Id]/edit/page.js

@@ -25,7 +25,7 @@ export default function Page({ params }: PageProps) {
         <div className="container">
           <div className="flex justify-between m-4 mt-8">
             <div className="text-xl text-primary flex gap-2 items-center">
-              {l("shared.updateModel", { model: l("${dict.model}.modelName") })}
+              {l("base.updateModel", { model: l("${dict.model}.modelName") })}
             </div>
           </div>
           <Load.Edit

package/esm/src/templates/crudPages/[__model__Id]/page.js

@@ -40,7 +40,7 @@ export default function Page({ params }: PageProps) {
             <${dict.Model}.Zone.View view={${dict.model}View} />
             <Link href={\`/${dict.model}/\${${dict.model}.id}/edit\`}>
               <button className="btn">
-                {l("shared.updateModel", { model: l("${dict.model}.modelName") })}
+                {l("base.updateModel", { model: l("${dict.model}.modelName") })}
               </button>
             </Link>
           </div>

package/esm/src/templates/crudPages/new/page.js

@@ -20,7 +20,7 @@ export default function Page() {
         <div className="container">
           <div className="flex justify-between m-4 mt-8">
             <div className="text-xl text-primary flex gap-2 items-center">
-              + {l("shared.createModel", { model: l("${dict.model}.modelName") })}
+              + {l("base.createModel", { model: l("${dict.model}.modelName") })}
             </div>
           </div>
           <Load.Edit

package/esm/src/templates/crudPages/page.js

@@ -23,7 +23,7 @@ export default function Page() {
             <div className="animate-fadeIn px-4 pt-4 flex gap-4 items-center">
               <div className="font-bold text-lg md:text-4xl">${dict.Model}s</div>
               <Link href={\`/${dict.model}/new\`}>
-                <button className="btn">+ {l("shared.createModel", { model: l("${dict.model}.modelName") })}</button>
+                <button className="btn">+ {l("base.createModel", { model: l("${dict.model}.modelName") })}</button>
               </Link>
             </div>
             <div>{l("${dict.model}.modelDesc")}</div>

package/esm/src/templates/index.js

@@ -2,7 +2,6 @@
 function getContent(scanInfo, dict = {}) {
   return `
 export * as cnst from "./lib/cnst";
-export { fetch } from "./lib/sig";
 `;
 }
 export {

package/esm/src/templates/lib/__lib/lib.constant.js

@@ -27,7 +27,6 @@ ${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
   lights: [${extendedModels2.map((libName) => `${libName}.Light${ModelName}`).join(", ")}] as const,
   models: [${extendedModels2.map((libName) => `${libName}.${ModelName}`).join(", ")}] as const,
   insights: [${extendedModels2.map((libName) => `${libName}.${ModelName}Insight`).join(", ")}] as const,
-  filters: [${extendedModels2.map((libName) => `${libName}.${ModelName}Filter`).join(", ")}] as const,
 }`;
   }).join("\n")}