@aurorajs.dev/catalyst-cli 1.0.1 → 1.1.3

package/dist/templates/codegen/backend/@app/__module_name__/application/__bounded_context_name__-__module_name__.payload-types.ts.eta

@@ -0,0 +1,53 @@
+/**
+* @aurora-catalyst-generated
+* @source cliter/<%= it.fmt.toKebabCase(it.schema.boundedContextName) %>/<%= it.fmt.toKebabCase(it.schema.moduleName) %>.aurora.yaml
+*/
+<%_
+  /* Internal service payload types (design.md D5/D6/D7, non-editable-field-codegen):
+     the public write input widened with the readonly properties as OPTIONAL
+     members, so a backend cascade can still write them atomically alongside
+     everything else in a SINGLE write, while the public contract (DTOs,
+     GraphQL inputs) never advertises them as writable. Emitted only when the
+     aggregate declares at least one readonly property — see the sibling
+     excludedFiles gate in back.handler.ts (design.md D5, tasks.md 3.7). */
+  const bcPascal = it.fmt.toPascalCase(it.schema.boundedContextName);
+  const modPascal = it.fmt.toPascalCase(it.schema.moduleName);
+  const modsPascal = it.fmt.toPascalCase(it.schema.moduleNames);
+  const createInput = `${bcPascal}Create${modPascal}Input`;
+  const updateByIdInput = `${bcPascal}Update${modPascal}ByIdInput`;
+  const updateInput = `${bcPascal}Update${modsPascal}Input`;
+  const fields = it.readonlyPayload.getReadonlyPayloadFields(it.schema);
+  const enumFieldTypes = [...new Set(
+    fields
+      .map((f) => f.type)
+      .filter((t) => t.endsWith('Enum')),
+  )];
+  const importsArray = [
+    { items: [createInput, updateByIdInput, updateInput, ...enumFieldTypes], path: '@api/graphql' },
+  ];
+_%>
+<%~ it.gen.importManager({ imports: importsArray }) %>
+
+/**
+ * Internal service payload types for <%= it.schema.aggregateName %> — the public
+ * write input intersected with its readonly properties as optional members.
+ * Only the generated write SERVICES type their payload with these; handlers,
+ * resolvers and controllers keep the narrower public input (design.md D8).
+ */
+export type <%= bcPascal %>Create<%= modPascal %>Payload = <%= createInput %> & {
+<% for (const f of fields) { -%>
+  <%= f.name %>?: <%= f.type %>;
+<% } -%>
+};
+
+export type <%= bcPascal %>Update<%= modPascal %>ByIdPayload = <%= updateByIdInput %> & {
+<% for (const f of fields) { -%>
+  <%= f.name %>?: <%= f.type %>;
+<% } -%>
+};
+
+export type <%= bcPascal %>Update<%= modsPascal %>Payload = <%= updateInput %> & {
+<% for (const f of fields) { -%>
+  <%= f.name %>?: <%= f.type %>;
+<% } -%>
+};

package/dist/templates/codegen/backend/@app/__module_name__/application/count/__bounded_context_name__-count-__module_name__.handler.ts.eta

@@ -5,24 +5,14 @@
 <%_
   let importsArray = [
     { items: ['Injectable', 'NotFoundException'], path: '@nestjs/common' },
-    { items: ['QueryStatement'], path: it.config.AURORA_CORE_COMMON },
     { items: it.schema.aggregateName, path: '@api/graphql' },
+    { items: ['HandlerMeta', 'QueryStatement'], path: it.config.AURORA_CORE_BACK },
     {
-      items: `${it.fmt.toPascalCase(it.schema.boundedContextName)}Count${it.fmt.toPascalCase(it.schema.moduleName)}Service`,
-      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}`,
-    },
-    {
-      items: ['HandlerMeta'],
-      path: it.config.AURORA_CORE_BACK,
+      items: [`${it.fmt.toPascalCase(it.schema.boundedContextName)}Count${it.fmt.toPascalCase(it.schema.moduleName)}Service`],
+      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/application/count/${it.fmt.toKebabCase(it.schema.boundedContextName)}-count-${it.fmt.toKebabCase(it.schema.moduleName)}.service`,
     },
   ];
 _%>
-<% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-<%_ importsArray.push(
-  { items: ['BadRequestException'], path: '@nestjs/common' },
-  { items: ['CoreAddI18nConstraintService', 'CoreGetSearchKeyLangService', 'Utils'], path: it.config.AURORA_CORE_BACK },
-); _%>
-<% } -%>
 <% if (it.schema.hasTenant) { -%>
 <%_ importsArray.push({ items: 'IamAccountResponse', path: `${it.config.APP_CONTAINER}/iam/account` }); _%>
 <% } -%>
@@ -30,18 +20,8 @@ _%>
 @Injectable()
 export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Count<%= it.fmt.toPascalCase(it.schema.moduleName) %>Handler
 {
-  <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-  i18nColumns: string[] = [<% for (const [i, prop] of it.filters.getI18nSearchableProperties(it.schema.aggregateProperties, [`${it.fmt.toCamelCase(it.schema.moduleName)}Id`]).entries()) { -%>'<%= it.fmt.toCamelCase(it.mappers.getPropertyName(prop)) %>'<% if (i < it.filters.getI18nSearchableProperties(it.schema.aggregateProperties, [`${it.fmt.toCamelCase(it.schema.moduleName)}Id`]).length - 1) { -%>, <% } -%><% } -%>];
-  i18nRelationship: string = '<%= it.fmt.toCamelCase(it.schema.moduleName) %>I18n';
-  i18nFunctionReplace = (key: string): string => this.i18nColumns.includes(key) ? `$${this.i18nRelationship}.${key}$` : key;
-
-  <% } -%>
   constructor(
     private readonly countService: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Count<%= it.fmt.toPascalCase(it.schema.moduleName) %>Service,
-    <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    private readonly coreAddI18nConstraintService: CoreAddI18nConstraintService,
-    private readonly coreGetSearchKeyLangService: CoreGetSearchKeyLangService,
-    <% } -%>
   ) {}
 
   async main(
@@ -53,24 +33,6 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Count<%= it
     handlerMeta?: HandlerMeta,
   ): Promise<number>
   {
-    <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    const contentLanguage = handlerMeta?.meta?.contentLanguage as string;
-    if (!contentLanguage) throw new BadRequestException('To find a multi-language object, the content-language header must be defined.');
-
-    constraint = await this.coreAddI18nConstraintService.add(
-      constraint,
-      this.i18nRelationship,
-      contentLanguage,
-      {
-        searchKeyLang: this.coreGetSearchKeyLangService.get(),
-      },
-    );
-
-    // Replace all i18n keys by $<%= it.fmt.toCamelCase(it.schema.moduleName) %>I18n.key$
-    queryStatement = Utils.deepMapKeys(queryStatement, this.i18nFunctionReplace);
-    constraint = Utils.deepMapKeys(constraint, this.i18nFunctionReplace);
-
-    <% } -%>
     return await this.countService.main(
       queryStatement,
       constraint,

package/dist/templates/codegen/backend/@app/__module_name__/application/count/__bounded_context_name__-count-__module_name__.service.ts.eta

@@ -4,19 +4,18 @@
 */
 <%_ let importsArray = [
   { items: ['Injectable'], path: '@nestjs/common' },
-  { items: ['QueryStatement'], path: it.config.AURORA_CORE_COMMON },
-  { items: ['HandlerMeta'], path: it.config.AURORA_CORE_BACK },
+  { items: ['HandlerMeta', 'QueryStatement'], path: it.config.AURORA_CORE_BACK },
   {
-    items: `${it.fmt.toPascalCase(it.schema.boundedContextName)}Sequelize${it.fmt.toPascalCase(it.schema.moduleName)}Repository`,
-    path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}`,
-  },
+      items: [`${it.fmt.toPascalCase(it.schema.boundedContextName)}Drizzle${it.fmt.toPascalCase(it.schema.moduleName)}Repository`],
+      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/infrastructure/drizzle/${it.fmt.toKebabCase(it.schema.boundedContextName)}-drizzle-${it.fmt.toKebabCase(it.schema.moduleName)}.repository`,
+    },
 ]; _%>
 <%~ it.gen.importManager({ imports: importsArray }) %>
 @Injectable()
 export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Count<%= it.fmt.toPascalCase(it.schema.moduleName) %>Service
 {
   constructor(
-    private readonly repository: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Sequelize<%= it.fmt.toPascalCase(it.schema.moduleName) %>Repository,
+    private readonly repository: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Drizzle<%= it.fmt.toPascalCase(it.schema.moduleName) %>Repository,
   ) {}
 
   async main(

package/dist/templates/codegen/backend/@app/__module_name__/application/create/__bounded_context_name__-create-__module_name__.handler.ts.eta

@@ -3,8 +3,11 @@
 * @source cliter/<%= it.fmt.toKebabCase(it.schema.boundedContextName) %>/<%= it.fmt.toKebabCase(it.schema.moduleName) %>.aurora.yaml
 */
 <%_
+  const isI18nTable = it.i18nStrategy === 'table' && it.filters.hasI18nProperties(it.schema.aggregateProperties ?? []);
+  const isI18nEmbedded = it.i18nEmbedded.isEmbeddedI18n(it.filters.hasI18nProperties(it.schema.aggregateProperties ?? []), it.i18nStrategy);
+  const i18nRelationLabel = it.i18nTable.getI18nTableRelationLabel(it.schema);
   let importsArray = [
-    { items: ['Injectable'], path: '@nestjs/common' },
+    { items: isI18nTable ? ['BadRequestException', 'Injectable'] : ['Injectable'], path: '@nestjs/common' },
     {
       items: [
         it.schema.aggregateName,
@@ -13,11 +16,12 @@
       path: '@api/graphql',
     },
     {
-      items: [
-        `${it.fmt.toPascalCase(it.schema.boundedContextName)}Create${it.fmt.toPascalCase(it.schema.moduleName)}Service`,
-        `${it.fmt.toPascalCase(it.schema.boundedContextName)}Find${it.fmt.toPascalCase(it.schema.moduleName)}ByIdService`,
-      ],
-      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}`,
+      items: [`${it.fmt.toPascalCase(it.schema.boundedContextName)}Create${it.fmt.toPascalCase(it.schema.moduleName)}Service`],
+      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/application/create/${it.fmt.toKebabCase(it.schema.boundedContextName)}-create-${it.fmt.toKebabCase(it.schema.moduleName)}.service`,
+    },
+    {
+      items: [`${it.fmt.toPascalCase(it.schema.boundedContextName)}Find${it.fmt.toPascalCase(it.schema.moduleName)}ByIdService`],
+      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/application/find/${it.fmt.toKebabCase(it.schema.boundedContextName)}-find-${it.fmt.toKebabCase(it.schema.moduleName)}-by-id.service`,
     },
     {
       items: ['EventEmitter2'],
@@ -28,17 +32,15 @@
       path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/domain`,
     },
     {
-      items: ['ApplySchema', 'EmitEvent', 'HandlerMeta'],
+      items: isI18nTable
+        ? ['ApplySchema', 'CoreAddI18nConstraintService', 'CoreGetContentLanguageObjectService', 'EmitEvent', 'HandlerMeta']
+        : isI18nEmbedded
+          ? ['ApplySchema', 'CoreI18nEmbeddedService', 'EmitEvent', 'HandlerMeta']
+          : ['ApplySchema', 'EmitEvent', 'HandlerMeta'],
       path: it.config.AURORA_CORE_BACK,
     },
   ];
 _%>
-<% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-<%_ importsArray.push(
-  { items: ['BadRequestException'], path: '@nestjs/common' },
-  { items: ['CoreAddI18nConstraintService', 'CoreGetSearchKeyLangService', 'CoreGetFallbackLangService', 'CoreGetContentLanguageObjectService'], path: it.config.AURORA_CORE_BACK },
-); _%>
-<% } -%>
 <% if (it.schema.hasTenant) { -%>
 <%_ importsArray.push({ items: 'IamAccountResponse', path: `${it.config.APP_CONTAINER}/iam/account` }); _%>
 <% } -%>
@@ -50,55 +52,60 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= i
     private readonly eventEmitter: EventEmitter2,
     private readonly createService: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Service,
     private readonly findByIdService: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Find<%= it.fmt.toPascalCase(it.schema.moduleName) %>ByIdService,
-    <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    private readonly coreAddI18nConstraintService: CoreAddI18nConstraintService,
+<% if (isI18nTable) { -%>
     private readonly coreGetContentLanguageObjectService: CoreGetContentLanguageObjectService,
-    private readonly coreGetFallbackLangService: CoreGetFallbackLangService,
-    private readonly coreGetSearchKeyLangService: CoreGetSearchKeyLangService,
-    <% } -%>
+    private readonly coreAddI18nConstraintService: CoreAddI18nConstraintService,
+<% } -%>
+<% if (isI18nEmbedded) { -%>
+    private readonly i18nService: CoreI18nEmbeddedService,
+<% } -%>
   ) {}
 
   @EmitEvent('<%= it.fmt.toCamelCase(it.schema.boundedContextName) %>.<%= it.fmt.toCamelCase(it.schema.moduleName) %>.created')
   @ApplySchema(<%= it.schema.aggregateName %>FieldSchema)
   async main(
+    payload: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Input,
     <% if (it.schema.hasTenant) { -%>
     account: IamAccountResponse,
     <% } -%>
-    payload: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Input,
     handlerMeta?: HandlerMeta,
   ): Promise<<%= it.fmt.toPascalCase(it.schema.boundedContextName) %><%= it.fmt.toPascalCase(it.schema.moduleName) %>>
   {
-    <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    const contentLanguage = handlerMeta?.meta?.contentLanguage as string;
-    if (!contentLanguage) throw new BadRequestException('To create a multi-language object, the content-language header must be defined.');
+<% if (isI18nEmbedded) { -%>
+<%~ include('/partials/i18n-validate', { ...it, i18nValidateMode: 'unconditional', i18nValidateSource: 'payload' }) -%>
+<%~ include('/partials/i18n-recompute', { ...it, i18nRecomputeSource: 'payload' }) -%>
 
-    <% } -%>
     await this.createService.main(
-      payload,
-      <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-      {
-        ...handlerMeta,
-        meta: {
-          ...handlerMeta?.meta,
-          fallbackLang   : await this.coreGetFallbackLangService.get(),
-          contentLanguage: await this.coreGetContentLanguageObjectService.get(contentLanguage),
-        },
-      },
-      <% } else { -%>
+      { ...payload, ...i18nRecompute },
       handlerMeta,
-      <% } -%>
     );
 
-    <% if (it.filters.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    const constraint = await this.coreAddI18nConstraintService.add(
+    return await this.findByIdService.main(
+      <% for (const prop of it.filters.getPrimaryKeyProperties(it.schema.aggregateProperties)) { -%>
+      payload.<%= it.fmt.toCamelCase(it.mappers.getPropertyName(prop)) %>,
+      <% } -%>
       {},
-      '<%= it.fmt.toCamelCase(it.schema.moduleName) %>I18n',
-      contentLanguage,
-      {
-        searchKeyLang: this.coreGetSearchKeyLangService.get(),
-      },
+      handlerMeta,
+    );
+<% } else if (isI18nTable) { -%>
+    // resolve the operation language from the Content-Language header (never the payload)
+    const lang = await this.coreGetContentLanguageObjectService.get(handlerMeta?.meta?.contentLanguage as string);
+
+    if (!lang)
+      throw new BadRequestException(
+        'The Content-Language header is required to create a <%= it.schema.aggregateName %> translation',
+      );
+
+    await this.createService.main(
+      payload,
+      lang,
+      handlerMeta,
     );
 
+    // re-add the i18n join so the just-written companion row comes back on the response
+    // (design.md D5) — an empty constraint would leave the translated fields undefined
+    const constraint = await this.coreAddI18nConstraintService.add({}, '<%= i18nRelationLabel %>', lang.iso6392);
+
     return await this.findByIdService.main(
       <% for (const prop of it.filters.getPrimaryKeyProperties(it.schema.aggregateProperties)) { -%>
       payload.<%= it.fmt.toCamelCase(it.mappers.getPropertyName(prop)) %>,
@@ -106,7 +113,12 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= i
       constraint,
       handlerMeta,
     );
-    <% } else { -%>
+<% } else { -%>
+    await this.createService.main(
+      payload,
+      handlerMeta,
+    );
+
     return await this.findByIdService.main(
       <% for (const prop of it.filters.getPrimaryKeyProperties(it.schema.aggregateProperties)) { -%>
       payload.<%= it.fmt.toCamelCase(it.mappers.getPropertyName(prop)) %>,
@@ -114,6 +126,6 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= i
       {},
       handlerMeta,
     );
-    <% } -%>
+<% } -%>
   }
 }

package/dist/templates/codegen/backend/@app/__module_name__/application/create/__bounded_context_name__-create-__module_name__.service.ts.eta

@@ -2,120 +2,138 @@
 * @aurora-catalyst-generated
 * @source cliter/<%= it.fmt.toKebabCase(it.schema.boundedContextName) %>/<%= it.fmt.toKebabCase(it.schema.moduleName) %>.aurora.yaml
 */
+<%_
+  const isI18nTable = it.i18nStrategy === 'table' && it.filters.hasI18nProperties(it.schema.aggregateProperties ?? []);
+  const bcPascal = it.fmt.toPascalCase(it.schema.boundedContextName);
+  const modPascal = it.fmt.toPascalCase(it.schema.moduleName);
+  const moduleVar = it.fmt.toCamelCase(it.schema.moduleName);
+  const fkName = it.i18nTable.getI18nTableForeignKeyName(it.schema);
+  const translatedLocalesField = it.fmt.toCamelCase(it.i18nEmbedded.TRANSLATED_LOCALES_COLUMN);
+  const i18nFieldNames = it.filters
+    .getI18nProperties(it.schema.aggregateProperties ?? [])
+    .map((prop) => it.fmt.toCamelCase(it.mappers.getPropertyName(prop)));
+  /* non-editable-field-codegen (design.md D5/D7/D8): a readonly property drops
+     out of the SDL input, so the public @api/graphql type can no longer carry
+     it — the internal Payload type widens it back so this SERVICE (called
+     directly by backend cascades, never by a client) can still write it. */
+  const createInputName = `${bcPascal}Create${modPascal}Input`;
+  const hasReadonly = it.readonlyPayload.hasReadonlyProperties(it.schema.aggregateProperties ?? []);
+  const createPayloadTypeName = hasReadonly ? it.readonlyPayload.getCreatePayloadTypeName(it.schema) : createInputName;
+_%>
 <%_ let importsArray = [
-  { items: 'Injectable', path: '@nestjs/common' },
-  { items: 'HandlerMeta', path: it.config.AURORA_CORE_BACK },
+  { items: isI18nTable ? ['ConflictException', 'Injectable'] : ['Injectable'], path: '@nestjs/common' },
+  { items: isI18nTable ? ['HandlerMeta', 'Uuid'] : ['HandlerMeta'], path: it.config.AURORA_CORE_BACK },
   {
-    items: [
-      `${it.fmt.toPascalCase(it.schema.boundedContextName)}Sequelize${it.fmt.toPascalCase(it.schema.moduleName)}Repository`,
-    ],
-    path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}`,
+    items: [`${bcPascal}Drizzle${modPascal}Repository`],
+    path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/infrastructure/drizzle/${it.fmt.toKebabCase(it.schema.boundedContextName)}-drizzle-${it.fmt.toKebabCase(it.schema.moduleName)}.repository`,
   },
+  ...(isI18nTable
+    ? [
+        {
+          items: [`${bcPascal}Drizzle${modPascal}I18nRepository`],
+          path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/infrastructure/drizzle/${it.fmt.toKebabCase(it.schema.boundedContextName)}-drizzle-${it.fmt.toKebabCase(it.schema.moduleName)}-i18n.repository`,
+        },
+      ]
+    : []),
   {
-    items: [
-      it.schema.aggregateName,
-    ],
+    items: hasReadonly ? [it.schema.aggregateName] : [it.schema.aggregateName, createInputName],
     path: '@api/graphql',
   },
 ]; _%>
-<% if (it.predicates.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-<%_ importsArray.push(
-  { items: ['ConflictException', 'NotFoundException'], path: '@nestjs/common' },
-  { items: `${it.fmt.toPascalCase(it.schema.boundedContextName)}I${it.fmt.toPascalCase(it.schema.moduleName)}I18nRepository`, path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}` },
-  { items: '* as _', path: 'lodash', defaultImport: true },
-); _%>
+<% if (hasReadonly) { -%>
+<%_ importsArray.push({
+  items: [createPayloadTypeName],
+  path: `../${it.readonlyPayload.getReadonlyPayloadTypesFileBaseName(it.schema)}`,
+}); _%>
 <% } -%>
 <%~ it.gen.importManager({ imports: importsArray }) %>
 @Injectable()
-export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Service
+export class <%= bcPascal %>Create<%= modPascal %>Service
 {
   constructor(
-    private readonly repository: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Sequelize<%= it.fmt.toPascalCase(it.schema.moduleName) %>Repository,
-    <%~ include('/partials/declare-i18n-repository', { ...it }) %>
+    private readonly repository: <%= bcPascal %>Drizzle<%= modPascal %>Repository,
+<% if (isI18nTable) { -%>
+    private readonly repositoryI18n: <%= bcPascal %>Drizzle<%= modPascal %>I18nRepository,
+<% } -%>
   ) {}
 
+<% if (isI18nTable) { -%>
   async main(
-    payload: any,
+    payload: <%= createPayloadTypeName %>,
+    lang: { id: string; iso6392: string },
     handlerMeta?: HandlerMeta,
   ): Promise<void>
   {
-    <% if (it.predicates.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    const fallbackLang = handlerMeta.meta.fallbackLang;
-    const contentLanguage = handlerMeta.meta.contentLanguage;
+    // split base <-> companion: the i18n fields are companion-only columns
+    const { <%= i18nFieldNames.join(', ') %>, ...baseData } = payload;
 
-    // override langId value object with header content-language value
-    payload.langId = new <%= it.fmt.toPascalCase(it.schema.boundedContextName) %><%= it.fmt.toPascalCase(it.schema.moduleName) %>I18nLangId(contentLanguage.id);
+    // check if the base row already exists to decide create-base vs add-translation
+    // `translatedLocales` is server-managed (design.md D6: write-only, excluded from the
+    // @api/graphql contract) — the base row's real Drizzle column is read here through a
+    // narrow, honest widening of the aggregate type, never `as any`/`as unknown as`.
+    const <%= moduleVar %> = (await this.repository.findById(payload.id, { handlerMeta })) as
+      | (<%= it.schema.aggregateName %> & { <%= translatedLocalesField %>?: string[] })
+      | null;
 
-    <% } -%>
+    if (<%= moduleVar %>) {
+      if ((<%= moduleVar %>.<%= translatedLocalesField %> ?? []).includes(lang.iso6392))
+        throw new ConflictException(
+          `Error to create <%= it.schema.aggregateName %>, the id ${payload.id} is already translated to ${lang.iso6392}`,
+        );
 
-    <% if (it.predicates.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-    // try get object from database
-    const <%= it.fmt.toCamelCase(it.schema.moduleName) %>InDB = await this.repository.findById(
-      <%= it.fmt.toCamelCase(it.schema.moduleName) %>.id,
-      <% if (it.predicates.hasI18nProperties(it.schema.aggregateProperties)) { -%>
-      {
-        constraint: {
-          include: [
-            {
-              association: '<%= it.fmt.toCamelCase(it.schema.moduleName) %>I18n',
-              where      : {
-                langId: fallbackLang.id,
-              },
-            },
-          ],
+      // base row exists: just union the new locale into translated_locales — the
+      // repository's own UpdateByIdInput generic already narrows to the base-row shape
+      // (Omit the companion-only i18n fields, add translatedLocales), so this plain
+      // literal typechecks with no cast needed
+      await this.repository.updateById(
+        {
+          id: payload.id,
+          <%= translatedLocalesField %>: [...new Set([...(<%= moduleVar %>.<%= translatedLocalesField %> ?? []), lang.iso6392])],
         },
-      },
-      <% } -%>
-    );
-
-    if (<%= it.fmt.toCamelCase(it.schema.moduleName) %>InDB)
-    {
-     if (<%= it.fmt.toCamelCase(it.schema.moduleName) %>InDB.availableLangs.value.includes(contentLanguage.id)) throw new ConflictException(`Error to create <%= it.schema.aggregateName %>, the id ${contentLanguage.id} already exist in database`);
-
-     // add available lang when create country
-     <%= it.fmt.toCamelCase(it.schema.moduleName) %>.availableLangs = new <%= it.fmt.toPascalCase(it.schema.boundedContextName) %><%= it.fmt.toPascalCase(it.schema.moduleName) %>AvailableLangs(_.union(<%= it.fmt.toCamelCase(it.schema.moduleName) %>InDB.availableLangs.value, [contentLanguage.id]));
-
-     await this.repository
-      .update(
-        <%= it.fmt.toCamelCase(it.schema.moduleName) %>,
         {
-          dataFactory: aggregate => _.pick(aggregate.toRepository(), 'id', 'availableLangs'),
-          updateOptions: handlerMeta?.repositoryOptions,
-          queryStatement: {
-            where: {
-              id: <%= it.fmt.toCamelCase(it.schema.moduleName) %>.id.value,
-            },
-          },
+          handlerMeta,
+          updateByIdOptions: handlerMeta?.repositoryOptions,
         },
       );
-    }
-    else
-    {
-     <%= it.fmt.toCamelCase(it.schema.moduleName) %>.availableLangs = new <%= it.fmt.toPascalCase(it.schema.boundedContextName) %><%= it.fmt.toPascalCase(it.schema.moduleName) %>AvailableLangs([contentLanguage.id]);
-     await this.repository
-      .create(
-       <%= it.fmt.toCamelCase(it.schema.moduleName) %>,
-       {
-         createOptions: handlerMeta?.repositoryOptions,
-       },
+    } else {
+      // first translation: create the base row seeded with this locale
+      await this.repository.create(
+        {
+          ...baseData,
+          <%= translatedLocalesField %>: [lang.iso6392],
+        },
+        {
+          createOptions: handlerMeta?.repositoryOptions,
+        },
       );
     }
 
-    // save new i18n record
+    // create the companion row for this (parent, language) pair
     await this.repositoryI18n.create(
-      <%= it.fmt.toCamelCase(it.schema.moduleName) %>,
       {
-        dataFactory: (aggregate: <%= it.schema.aggregateName %> ) => aggregate.toI18nRepository(),
-        finderQueryStatement: (aggregate: <%= it.schema.aggregateName %> ) => ({
+        id: Uuid.generate(),
+        <%= fkName %>: payload.id,
+        langId: lang.id,
+        <%= i18nFieldNames.join(', ') %>,
+      },
+      {
+        createOptions: handlerMeta?.repositoryOptions,
+        finderQueryStatement: () => ({
           where: {
-            <%= it.fmt.toCamelCase(it.schema.moduleName) %>Id: aggregate['id']['value'],
-            langId: aggregate['langId']['value'],
+            <%= fkName %>: { eq: payload.id },
+            langId: { eq: lang.id },
           },
         }),
-        createOptions: handlerMeta?.repositoryOptions,
       },
     );
-    <% } else { -%>
+  }
+<% } else { -%>
+  async main(
+    payload: <%= createPayloadTypeName %>,
+    handlerMeta?: HandlerMeta,
+  ): Promise<void>
+  {
+
     await this.repository.create(
       payload, {
         createOptions: handlerMeta?.repositoryOptions,
@@ -123,13 +141,13 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= i
         finderQueryStatement: (aggregate: <%= it.schema.aggregateName %>) => ({
           where: {
             <% for (const prop of it.filters.getPrimaryKeyProperties(it.schema.aggregateProperties)) { -%>
-            <%= prop.name %>: aggregate.<%= prop.name %>,
+            <%= prop.name %>: { eq: aggregate.<%= prop.name %> },
             <% } -%>
           },
         }),
         <% } -%>
       },
     );
-    <% } -%>
   }
+<% } -%>
 }

package/dist/templates/codegen/backend/@app/__module_name__/application/create/__bounded_context_name__-create-__module_names__.handler.ts.eta

@@ -3,9 +3,14 @@
 * @source cliter/<%= it.fmt.toKebabCase(it.schema.boundedContextName) %>/<%= it.fmt.toKebabCase(it.schema.moduleName) %>.aurora.yaml
 */
 <%_
+  const isI18nTable = it.i18nStrategy === 'table' && it.filters.hasI18nProperties(it.schema.aggregateProperties ?? []);
+  const isI18nEmbedded = it.i18nEmbedded.isEmbeddedI18n(it.filters.hasI18nProperties(it.schema.aggregateProperties ?? []), it.i18nStrategy);
   let importsArray = [
-    { items: 'Injectable', path: '@nestjs/common' },
-    { items: `${it.fmt.toPascalCase(it.schema.boundedContextName)}Create${it.fmt.toPascalCase(it.schema.moduleNames)}Service`, path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}` },
+    { items: isI18nTable ? ['BadRequestException', 'Injectable'] : ['Injectable'], path: '@nestjs/common' },
+    {
+      items: [`${it.fmt.toPascalCase(it.schema.boundedContextName)}Create${it.fmt.toPascalCase(it.schema.moduleNames)}Service`],
+      path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/application/create/${it.fmt.toKebabCase(it.schema.boundedContextName)}-create-${it.fmt.toKebabCase(it.schema.moduleNames)}.service`,
+    },
     { items: `${it.fmt.toPascalCase(it.schema.boundedContextName)}Create${it.fmt.toPascalCase(it.schema.moduleName)}Input`, path: '@api/graphql' },
     {
       items: ['EventEmitter2'],
@@ -16,7 +21,11 @@
       path: `${it.config.APP_CONTAINER}/${it.fmt.toKebabCase(it.schema.boundedContextName)}/${it.fmt.toKebabCase(it.schema.moduleName)}/domain`,
     },
     {
-      items: ['ApplySchema', 'EmitEvent', 'HandlerMeta'],
+      items: isI18nTable
+        ? ['ApplySchema', 'CoreGetContentLanguageObjectService', 'EmitEvent', 'HandlerMeta']
+        : isI18nEmbedded
+          ? ['ApplySchema', 'CoreI18nEmbeddedService', 'EmitEvent', 'HandlerMeta']
+          : ['ApplySchema', 'EmitEvent', 'HandlerMeta'],
       path: it.config.AURORA_CORE_BACK,
     },
   ];
@@ -31,22 +40,55 @@ export class <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= i
   constructor(
     private readonly eventEmitter: EventEmitter2,
     private readonly createService: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleNames) %>Service,
+<% if (isI18nTable) { -%>
+    private readonly coreGetContentLanguageObjectService: CoreGetContentLanguageObjectService,
+<% } -%>
+<% if (isI18nEmbedded) { -%>
+    private readonly i18nService: CoreI18nEmbeddedService,
+<% } -%>
   ) {}
 
   @EmitEvent('<%= it.fmt.toCamelCase(it.schema.boundedContextName) %>.<%= it.fmt.toCamelCase(it.schema.moduleName) %>.created', { returnInputPayload: true })
   @ApplySchema(<%= it.schema.aggregateName %>FieldSchema)
   async main(
+    payload: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Input[],
     <% if (it.schema.hasTenant) { -%>
     account: IamAccountResponse,
     <% } -%>
-    payload: <%= it.fmt.toPascalCase(it.schema.boundedContextName) %>Create<%= it.fmt.toPascalCase(it.schema.moduleName) %>Input[],
     handlerMeta?: HandlerMeta,
   ): Promise<boolean>
   {
+<% if (isI18nTable) { -%>
+    // resolve the operation language from the Content-Language header (never the payload)
+    const lang = await this.coreGetContentLanguageObjectService.get(handlerMeta?.meta?.contentLanguage as string);
+
+    if (!lang)
+      throw new BadRequestException(
+        'The Content-Language header is required to create <%= it.schema.aggregateName %> translations',
+      );
+
+    await this.createService.main(
+      payload,
+      lang,
+      handlerMeta,
+    );
+<% } else if (isI18nEmbedded) { -%>
+<%~ include('/partials/i18n-validate', { ...it, i18nValidateMode: 'union', i18nValidateSource: 'payload' }) -%>
+
+    await this.createService.main(
+      payload.map((item) => {
+<%~ include('/partials/i18n-recompute', { ...it, i18nRecomputeSource: 'item' }) -%>
+
+        return { ...item, ...i18nRecompute };
+      }),
+      handlerMeta,
+    );
+<% } else { -%>
     await this.createService.main(
       payload,
       handlerMeta,
     );
+<% } -%>
 
     return true;
   }