@starci/hfs 5.0.8 → 5.2.0

package/templates/be/patterns/saga/saga.done.consumer.ts.tpl

@@ -8,7 +8,7 @@ import { Complete@@Saga@@Command } from "../../application/complete-@@saga@@.com
 @Injectable()
 /** Consumer of `@@from@@.@@done@@`, the last event of the @@saga@@ saga: hands each delivery to the complete command. */
 export class @@Done@@Consumer implements EventConsumer<@@Done@@Event> {
-    readonly event = @@Done@@Event
+    readonly event: typeof @@Done@@Event = @@Done@@Event
 
     constructor(@InjectCommandBus() private readonly commandBus: CommandBus) {}
 

package/templates/be/patterns/saga/saga.failed.consumer.ts.tpl

@@ -8,7 +8,7 @@ import { Compensate@@Saga@@Command } from "../../application/compensate-@@saga@@
 @Injectable()
 /** Consumer of `@@from@@.@@failed@@`, the failure event of the @@saga@@ saga: hands each delivery to the compensate command. */
 export class @@Failed@@Consumer implements EventConsumer<@@Failed@@Event> {
-    readonly event = @@Failed@@Event
+    readonly event: typeof @@Failed@@Event = @@Failed@@Event
 
     constructor(@InjectCommandBus() private readonly commandBus: CommandBus) {}
 

package/templates/be/patterns/saga/saga.message.module-definition.ts.tpl

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { @@Saga@@MessageOptions } from "./@@saga@@-message.options"
 
+const built = new ConfigurableModuleBuilder<@@Saga@@MessageOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<@@Saga@@MessageOptions, "register", "create", {}>
+
 /** The configurable-module base of the @@saga@@-message module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<@@Saga@@MessageOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/patterns/saga/saga.module-definition.ts.tpl

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { @@Saga@@Options } from "./@@saga@@.options"
 
+const built = new ConfigurableModuleBuilder<@@Saga@@Options>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<@@Saga@@Options, "register", "create", {}>
+
 /** The configurable-module base of the @@saga@@ module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<@@Saga@@Options>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/patterns/webhooks/webhook.http.module-definition.ts.tpl

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { @@Provider@@HttpOptions } from "./@@provider@@-http.options"
 
+const built = new ConfigurableModuleBuilder<@@Provider@@HttpOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<@@Provider@@HttpOptions, "register", "create", {}>
+
 /** The configurable-module base of the @@provider@@-http module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<@@Provider@@HttpOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/platform/graphql/graphql.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { GraphqlOptions } from "./graphql.options"
 
-/** The configurable-module base of the graphql capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<GraphqlOptions>()
+const built = new ConfigurableModuleBuilder<GraphqlOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<GraphqlOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the graphql capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/features/api/system-health/system-health.module-definition.ts

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { SystemHealthOptions } from "./system-health.options"
 
+const built = new ConfigurableModuleBuilder<SystemHealthOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<SystemHealthOptions, "register", "create", {}>
+
 /** The configurable-module base of the system-health module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<SystemHealthOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/features/api/system-health/transport/http/system-health-http.module-definition.ts

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { SystemHealthHttpOptions } from "./system-health-http.options"
 
+const built = new ConfigurableModuleBuilder<SystemHealthHttpOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<SystemHealthHttpOptions, "register", "create", {}>
+
 /** The configurable-module base of the system-health-http module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<SystemHealthHttpOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/features/cli/cli.module-definition.ts

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { CliOptions } from "./cli.options"
 
+const built = new ConfigurableModuleBuilder<CliOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<CliOptions, "register", "create", {}>
+
 /** The configurable-module base of the cli module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<CliOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/features/cli/migrate/migrate.module-definition.ts

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { MigrateOptions } from "./migrate.options"
 
+const built = new ConfigurableModuleBuilder<MigrateOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<MigrateOptions, "register", "create", {}>
+
 /** The configurable-module base of the migrate module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<MigrateOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/features/cli/seed/seed.module-definition.ts

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { SeedOptions } from "./seed.options"
 
+const built = new ConfigurableModuleBuilder<SeedOptions>().setClassMethodName("register").build()
+type Host = ConfigurableModuleHost<SeedOptions, "register", "create", {}>
+
 /** The configurable-module base of the seed module. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<SeedOptions>().setClassMethodName("register").build()
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/domain/identity/identity.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { IdentityOptions } from "./identity.options"
 
-/** The configurable-module base of the identity capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<IdentityOptions>()
+const built = new ConfigurableModuleBuilder<IdentityOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<IdentityOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the identity capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/domain/liveness/liveness.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { LivenessOptions } from "./liveness.options"
 
-/** The configurable-module base of the liveness capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<LivenessOptions>()
+const built = new ConfigurableModuleBuilder<LivenessOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<LivenessOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the liveness capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/domain/note/note.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { NoteOptions } from "./note.options"
 
-/** The configurable-module base of the note capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<NoteOptions>()
+const built = new ConfigurableModuleBuilder<NoteOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<NoteOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the note capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/domain/note/persistence/connection.ts

@@ -1,8 +1,9 @@
+import type { DatabaseConnectionOptions } from "@modules/platform/database"
 import { NoteEntity } from "./entities/note.entity"
 import { InitNote1790000000000 } from "./migrations/1790000000000-init-note"
 
 /** The entities of the note capability, for the connection that holds them. */
-export const noteEntities = [NoteEntity]
+export const noteEntities: DatabaseConnectionOptions["entities"] = [NoteEntity]
 
 /** The migrations of the note capability, in the order they run. */
-export const noteMigrations = [InitNote1790000000000]
+export const noteMigrations: DatabaseConnectionOptions["migrations"] = [InitNote1790000000000]

package/templates/be/skeleton/src/modules/domain/note/persistence/note.sql.ts

@@ -1,4 +1,5 @@
 import { sql } from "@modules/platform/database"
+import type { SqlText } from "@modules/platform/database"
 
 /** Writes one note ($1 body, $2 written at) and answers the stored row. */
-export const INSERT_NOTE = sql`INSERT INTO notes (body, created_at) VALUES ($1, $2) RETURNING id, body, created_at`
+export const INSERT_NOTE: SqlText = sql`INSERT INTO notes (body, created_at) VALUES ($1, $2) RETURNING id, body, created_at`

package/templates/be/skeleton/src/modules/platform/clock/clock.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { ClockOptions } from "./clock.options"
 
-/** The configurable-module base of the clock capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<ClockOptions>()
+const built = new ConfigurableModuleBuilder<ClockOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<ClockOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the clock capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/cqrs/cqrs.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { CqrsOptions } from "./cqrs.options"
 
-/** The configurable-module base of the cqrs capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<CqrsOptions>()
+const built = new ConfigurableModuleBuilder<CqrsOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<CqrsOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the cqrs capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/database/database.module-definition.ts

@@ -1,9 +1,8 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { DATABASE_OPTIONS } from "./database.port"
 import type { DatabaseOptions } from "./database.options"
 
-/** The configurable-module base of the database capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<DatabaseOptions>({
+const built = new ConfigurableModuleBuilder<DatabaseOptions>({
     optionsInjectionToken: DATABASE_OPTIONS,
 })
     .setExtras({ isGlobal: false }, (definition, extras) => ({
@@ -11,3 +10,9 @@ export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleB
         global: extras.isGlobal,
     }))
     .build()
+type Host = ConfigurableModuleHost<DatabaseOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the database capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/database/index.ts

@@ -6,6 +6,7 @@ export { DEFAULT_SEED_ENV } from "./seed-connections.client"
 export { SeedRunnerService } from "./seed-runner.service"
 export type { DatabaseConnectionConfig, DatabaseConnectionOptions } from "./database.options"
 export { LIST_ROWS_MAX, sql } from "./database.sql"
+export type { SqlText } from "./database.sql"
 export { DATABASE_ERROR_KINDS } from "./errors/database.error"
 export { returnedRows, rowShape } from "./returned-rows.policy"
 export { parsePrimaryDatabaseConfig } from "./primary.config"

package/templates/be/skeleton/src/modules/platform/errors/errors.module-definition.ts

@@ -1,9 +1,15 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { ERRORS_OPTIONS } from "./errors.decorators"
 import type { ErrorsOptions } from "./errors.options"
 
-/** The configurable-module base of the errors capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<ErrorsOptions>({ optionsInjectionToken: ERRORS_OPTIONS })
+const built = new ConfigurableModuleBuilder<ErrorsOptions>({ optionsInjectionToken: ERRORS_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<ErrorsOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the errors capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/http/http.module-definition.ts

@@ -1,9 +1,13 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { HTTP_OPTIONS } from "./http.decorators"
 import type { HttpOptions } from "./http.options"
 
-/** The configurable-module base of the http capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<HttpOptions>({ optionsInjectionToken: HTTP_OPTIONS })
+const built = new ConfigurableModuleBuilder<HttpOptions>({ optionsInjectionToken: HTTP_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<HttpOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the http capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/http-security/http-security.module-definition.ts

@@ -1,9 +1,15 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { HTTP_SECURITY_OPTIONS } from "./http-security.decorators"
 import type { HttpSecurityOptions } from "./http-security.options"
 
-/** The configurable-module base of the http-security capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<HttpSecurityOptions>({ optionsInjectionToken: HTTP_SECURITY_OPTIONS })
+const built = new ConfigurableModuleBuilder<HttpSecurityOptions>({ optionsInjectionToken: HTTP_SECURITY_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<HttpSecurityOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the http-security capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/http-security/persistence/connection.ts

@@ -1,8 +1,9 @@
+import type { DatabaseConnectionOptions } from "@modules/platform/database"
 import { RateWindowEntity } from "./entities/rate-window.entity"
 import { CreateRateWindows1789900000000 } from "./migrations/1789900000000-create-rate-windows"
 
 /** The entities of the http-security capability, for the primary connection its rate limit counts in. */
-export const httpSecurityEntities = [RateWindowEntity]
+export const httpSecurityEntities: DatabaseConnectionOptions["entities"] = [RateWindowEntity]
 
 /** The migrations of the http-security capability, in the order they run. */
-export const httpSecurityMigrations = [CreateRateWindows1789900000000]
+export const httpSecurityMigrations: DatabaseConnectionOptions["migrations"] = [CreateRateWindows1789900000000]

package/templates/be/skeleton/src/modules/platform/http-security/persistence/rate-limit.sql.ts

@@ -1,10 +1,11 @@
 import { sql } from "@modules/platform/database"
+import type { SqlText } from "@modules/platform/database"
 
 /**
  * Counts one hit in the caller's window and answers the hits of that window: a missing or expired window opens afresh at one
  * hit and ends at $3 ($1 tier and address key, $2 instant, $3 end of a fresh window).
  */
-export const HIT_RATE_WINDOW = sql`INSERT INTO http_security_rate_windows (key, hits, reset_at)
+export const HIT_RATE_WINDOW: SqlText = sql`INSERT INTO http_security_rate_windows (key, hits, reset_at)
     VALUES ($1::varchar, 1, $3::timestamptz)
     ON CONFLICT (key) DO UPDATE SET
         hits = CASE WHEN http_security_rate_windows.reset_at <= $2::timestamptz THEN 1
@@ -14,7 +15,7 @@ export const HIT_RATE_WINDOW = sql`INSERT INTO http_security_rate_windows (key,
     RETURNING hits`
 
 /** Deletes a bounded batch of the windows that ended by $1; a second replica skips the rows this one holds. */
-export const PRUNE_RATE_WINDOWS = sql`DELETE FROM http_security_rate_windows WHERE key IN (
+export const PRUNE_RATE_WINDOWS: SqlText = sql`DELETE FROM http_security_rate_windows WHERE key IN (
     SELECT key FROM http_security_rate_windows WHERE reset_at <= $1::timestamptz
     LIMIT 100 FOR UPDATE SKIP LOCKED
 )`

package/templates/be/skeleton/src/modules/platform/i18n/i18n.module-definition.ts

@@ -1,9 +1,15 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { I18N_OPTIONS } from "./i18n.decorators"
 import type { I18nOptions } from "./i18n.options"
 
-/** The configurable-module base of the i18n capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<I18nOptions>({ optionsInjectionToken: I18N_OPTIONS })
+const built = new ConfigurableModuleBuilder<I18nOptions>({ optionsInjectionToken: I18N_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<I18nOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the i18n capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The injection token of the registered options. */
+export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/ids/ids.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { IdsOptions } from "./ids.options"
 
-/** The configurable-module base of the ids capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<IdsOptions>()
+const built = new ConfigurableModuleBuilder<IdsOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<IdsOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the ids capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/logging/logging.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { LoggingOptions } from "./logging.options"
 
-/** The configurable-module base of the logging capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<LoggingOptions>()
+const built = new ConfigurableModuleBuilder<LoggingOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<LoggingOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the logging capability; `isGlobal` is decided by the app root. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton/src/modules/platform/retry/retry.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { RetryOptions } from "./retry.options"
 
-/** The configurable-module base of the retry capability; the app root decides its global scope. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<RetryOptions>()
+const built = new ConfigurableModuleBuilder<RetryOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<RetryOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the retry capability; the app root decides its global scope. */
+export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
+/** The options of a synchronous registration, for the register signature. */
+export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE

package/templates/be/skeleton-lite/apps/api/src/app.module.ts

@@ -2,7 +2,7 @@ import { Module } from "@nestjs/common"
 import type { DynamicModule } from "@nestjs/common"
 import { APP_FILTER, APP_GUARD } from "@nestjs/core"
 import { AuthGuard, CredentialGuard } from "@modules/domain/identity"
-import { tokenKit } from "@modules/integrations/passport"
+import { passportKit } from "@modules/integrations/passport"
 import { ErrorsFilter } from "@modules/platform/errors"
 import { OriginGuard, RateLimitGuard } from "@modules/platform/http-security"
 import { platformModules } from "./compose/platform"
@@ -10,7 +10,7 @@ import { domainModules } from "./compose/domain"
 import { systemModules } from "./compose/system"
 import { apiModules } from "./compose/api"
 import { webhooksModules } from "./compose/webhooks"
-import { integrationProviders } from "./compose/integrations"
+import { integrationModules, integrationProviders } from "./compose/integrations"
 import type { ApiOptions } from "./api.options"
 
 @Module({})
@@ -18,18 +18,19 @@ import type { ApiOptions } from "./api.options"
 export class AppModule {
     /** Builds the module from options parsed once at boot; nothing here reads the environment. */
     static register(options: ApiOptions): DynamicModule {
-        const tokens = tokenKit(options.passport.tokens)
+        const passport = passportKit(options.passport)
         return {
             module: AppModule,
             imports: [
                 ...platformModules(options),
-                ...domainModules(tokens.verify),
+                ...integrationModules(options),
+                ...domainModules(passport.verify),
                 ...systemModules(),
                 ...apiModules(),
                 ...webhooksModules(),
             ],
             providers: [
-                ...integrationProviders(options, tokens.verify),
+                ...integrationProviders(options, passport.verify),
                 { provide: APP_FILTER, useClass: ErrorsFilter },
                 { provide: APP_GUARD, useClass: RateLimitGuard },
                 { provide: APP_GUARD, useClass: OriginGuard },

package/templates/be/skeleton-lite/apps/api/src/compose/api.ts

@@ -1,4 +1,5 @@
 import type { DynamicModule, Type } from "@nestjs/common"
+import { AuthHttpModule } from "@features/api/auth"
 
-/** The API transports of the app; `starci app add api` registers each generated door here. */
-export const apiModules = (): Array<Type<unknown> | DynamicModule> => []
+/** The API transports of the app: the sign-in doors; `starci app add api` registers each generated door here. */
+export const apiModules = (): Array<Type<unknown> | DynamicModule> => [AuthHttpModule.register({})]

package/templates/be/skeleton-lite/apps/api/src/compose/integrations.ts

@@ -1,12 +1,17 @@
-import type { Provider } from "@nestjs/common"
-import { OWN_TOKEN_VERIFIER, PASSPORT_OPTIONS } from "@modules/integrations/passport"
+import type { DynamicModule, Provider } from "@nestjs/common"
+import { OWN_TOKEN_VERIFIER, PASSPORT_OPTIONS, passportModule } from "@modules/integrations/passport"
 import type { VerifyAccessToken } from "@modules/integrations/passport"
-import { OBJECT_STORAGE, createObjectStorage } from "@modules/integrations/object-storage"
+import { ObjectStorageModule } from "@modules/integrations/object-storage"
 import type { ApiOptions } from "../api.options"
 
-/** The passport and object-storage integration ports bound once for this app. */
+/** The sign-in and object storage packages of the app, each registered once with the app's typed settings. */
+export const integrationModules = (options: ApiOptions): Array<DynamicModule> => [
+    passportModule(options.passport, { isGlobal: true }),
+    ObjectStorageModule.register({ ...options.objectStorage, isGlobal: true }),
+]
+
+/** The passport integration ports bound once for this app. */
 export const integrationProviders = (options: ApiOptions, verifyAccessToken: VerifyAccessToken): Array<Provider> => [
     { provide: PASSPORT_OPTIONS, useValue: options.passport },
     { provide: OWN_TOKEN_VERIFIER, useValue: verifyAccessToken },
-    { provide: OBJECT_STORAGE, useValue: createObjectStorage(options.objectStorage) },
 ]

package/templates/be/skeleton-lite/src/modules/domain/identity/errors/identity.error.ts

@@ -0,0 +1,34 @@
+import { DomainError } from "@modules/platform/errors"
+import type { ErrorKind } from "@modules/platform/errors"
+
+/** Codes of the identity capability: the sign-in refusals travel under these wire codes, the same on both sides of the doors. */
+export enum IdentityErrorCode {
+    /** The door needs a signed-in caller and the request establishes none. */
+    Unauthenticated = "IDENTITY_UNAUTHENTICATED",
+    /** The refresh token is unknown, expired or already spent. */
+    RefreshInvalid = "IDENTITY_REFRESH_INVALID",
+    /** A rotated refresh token was presented again: the session was ended. */
+    RefreshReused = "IDENTITY_REFRESH_REUSED",
+    /** The account is deleted or banned. */
+    AccountDisabled = "IDENTITY_ACCOUNT_DISABLED",
+    /** Too many failed attempts for this address; try again later. */
+    TooManyAttempts = "IDENTITY_TOO_MANY_ATTEMPTS",
+    /** The pair of address and password is wrong (the same answer for an unknown address). */
+    PairRefused = "IDENTITY_INVALID_CREDENTIALS",
+    /** The mailbox was never confirmed. */
+    EmailNotConfirmed = "IDENTITY_EMAIL_NOT_CONFIRMED",
+}
+
+/** How each identity code travels. */
+export const IDENTITY_ERROR_KINDS: Record<IdentityErrorCode, ErrorKind> = {
+    [IdentityErrorCode.Unauthenticated]: "unauthenticated",
+    [IdentityErrorCode.RefreshInvalid]: "unauthenticated",
+    [IdentityErrorCode.RefreshReused]: "unauthenticated",
+    [IdentityErrorCode.AccountDisabled]: "forbidden",
+    [IdentityErrorCode.TooManyAttempts]: "rate-limited",
+    [IdentityErrorCode.PairRefused]: "unauthenticated",
+    [IdentityErrorCode.EmailNotConfirmed]: "forbidden",
+}
+
+/** The one error class of the identity capability. */
+export class IdentityError extends DomainError<IdentityErrorCode> {}