@bgord/bun 1.21.7 → 1.21.9

package/src/encryption-iv.vo.ts

@@ -1,7 +1,7 @@
 export class EncryptionIV {
   static readonly LENGTH = 12;
 
-  static generate(): Uint8Array {
+  static generate(): Uint8Array<ArrayBuffer> {
     const iv = new Uint8Array(EncryptionIV.LENGTH);
     crypto.getRandomValues(iv);
 

package/src/encryption-key.vo.ts

@@ -24,7 +24,7 @@ export class EncryptionKey {
     return this.key === another.key;
   }
 
-  toBytes(): Uint8Array {
+  toBytes(): Uint8Array<ArrayBuffer> {
     return Uint8Array.fromHex(this.key);
   }
 

package/src/healthcheck-hono.handler.ts

@@ -16,10 +16,10 @@ export class HealthcheckHonoHandler implements HandlerHonoPort {
   }
 
   handle() {
-    return factory.createHandlers(async (c) => {
+    return factory.createHandlers(async () => {
       const healthcheck = await this.handler.check();
 
-      return c.json(healthcheck, healthcheck.code);
+      return Response.json(healthcheck, { status: healthcheck.code });
     });
   }
 }

package/src/id-provider-crypto.adapter.ts

@@ -1,8 +1,9 @@
+import * as v from "valibot";
 import type { IdProviderPort } from "./id-provider.port";
-import type { UUIDType } from "./uuid.vo";
+import { UUID, type UUIDType } from "./uuid.vo";
 
 export class IdProviderCryptoAdapter implements IdProviderPort {
   generate(): UUIDType {
-    return crypto.randomUUID();
+    return v.parse(UUID, crypto.randomUUID());
   }
 }

package/src/job-registry.adapter.ts

@@ -53,6 +53,6 @@ export class JobRegistryAdapter<Job extends GenericJob> implements JobRegistryPo
     const entry = this.map.get(name);
     if (!entry) throw new Error(JobRegistryAdapterError.UnknownJob);
 
-    return entry.handler as JobHandler<Job>;
+    return entry.handler;
   }
 }

package/src/languages.vo.ts

@@ -22,6 +22,6 @@ export class Languages<T extends tools.LanguageType> {
   }
 
   isSupported(value: unknown): value is T {
-    return this.values.includes(value as T);
+    return this.values.some((language) => language === value);
   }
 }

package/src/liveness-hono.handler.ts

@@ -8,10 +8,10 @@ export class LivenessHonoHandler implements HandlerHonoPort {
   private readonly handler = new LivenessHandler();
 
   handle() {
-    return factory.createHandlers(async (c) => {
+    return factory.createHandlers(async () => {
       const { headers, ...body } = this.handler.execute();
 
-      return c.json(body, 200, headers);
+      return Response.json(body, { status: 200, headers });
     });
   }
 }

package/src/message-bus-with-logger.adapter.ts

@@ -1,5 +1,5 @@
 import { CorrelationStorage } from "./correlation-storage.service";
-import type { LogCoreType, LoggerPort } from "./logger.port";
+import type { LoggerPort } from "./logger.port";
 import type { Message, ToMessageMap } from "./message.types";
 import type { MessageBusPort } from "./message-bus.port";
 
@@ -13,7 +13,7 @@ export class MessageBusWithLoggerAdapter<Messages extends Message> implements Me
   async emit<M extends Messages>(message: M): Promise<void> {
     this.deps.Logger.info({
       message: `${message.name} emitted`,
-      metadata: message as LogCoreType["metadata"],
+      metadata: message,
       correlationId: CorrelationStorage.get(),
       ...this.base,
     });

package/src/modules/history/value-objects/history-id.ts

@@ -1,3 +1,7 @@
+import * as v from "valibot";
 import { UUID } from "../../../uuid.vo";
 
-export const HistoryId = UUID;
+// Stryker disable next-line StringLiteral
+export const HistoryId = v.pipe(UUID, v.brand("HistoryId"));
+
+export type HistoryIdType = v.InferOutput<typeof HistoryId>;

package/src/modules/history/value-objects/history-operation.ts

@@ -10,4 +10,8 @@ export const HistoryOperation = v.pipe(
   v.string(HistoryOperationError.Type),
   v.minLength(1, HistoryOperationError.Empty),
   v.maxLength(128, HistoryOperationError.TooLong),
+  // Stryker disable next-line StringLiteral
+  v.brand("HistoryOperation"),
 );
+
+export type HistoryOperationType = v.InferOutput<typeof HistoryOperation>;

package/src/modules/history/value-objects/history-payload.ts

@@ -1,6 +1,12 @@
 import * as v from "valibot";
 
-export const HistoryPayload = v.record(v.string(), v.unknown());
+export const HistoryPayload = v.pipe(
+  v.record(v.string(), v.unknown()),
+  // Stryker disable next-line StringLiteral
+  v.brand("HistoryPayload"),
+);
+
+export type HistoryPayloadType = v.InferOutput<typeof HistoryPayload>;
 
 export const HistoryPayloadParsedError = {
   NotSerializable: "history.payload.parsed.not.serializable",
@@ -18,4 +24,8 @@ export const HistoryPayloadParsed = v.pipe(
     }
   }, HistoryPayloadParsedError.NotSerializable),
   v.transform((value) => JSON.stringify(value)),
+  // Stryker disable next-line StringLiteral
+  v.brand("HistoryPayloadParsed"),
 );
+
+export type HistoryPayloadParsedType = v.InferOutput<typeof HistoryPayloadParsed>;

package/src/modules/history/value-objects/history-subject.ts

@@ -10,6 +10,8 @@ export const HistorySubject = v.pipe(
   v.string(HistorySubjectError.Type),
   v.minLength(1, HistorySubjectError.Empty),
   v.maxLength(128, HistorySubjectError.TooLong),
+  // Stryker disable next-line StringLiteral
+  v.brand("HistorySubject"),
 );
 
 export type HistorySubjectType = v.InferOutput<typeof HistorySubject>;

package/src/readiness-hono.handler.ts

@@ -12,10 +12,10 @@ export class ReadinessHonoHandler implements HandlerHonoPort {
   }
 
   handle() {
-    return factory.createHandlers(async (c) => {
+    return factory.createHandlers(async () => {
       const result = await this.handler.check();
 
-      return c.json(result.details, result.code, result.headers);
+      return Response.json(result.details, { status: result.code, headers: result.headers });
     });
   }
 }

package/src/request-context-hono.adapter.ts

@@ -3,7 +3,9 @@ import * as tools from "@bgord/tools";
 import type { Context } from "hono";
 import { getConnInfo } from "hono/bun";
 import { getCookie } from "hono/cookie";
+import { HTTPException } from "hono/http-exception";
 import type { RequestContext } from "./request-context.port";
+import { ShieldAuthStrategyError } from "./shield-auth.strategy";
 
 export class RequestContextHonoAdapter implements RequestContext {
   readonly request: RequestContext["request"];
@@ -49,6 +51,13 @@ export class RequestContextHonoAdapter implements RequestContext {
 
     this.identity = {
       userId: () => context.get("user")?.id,
+      authenticatedUserId: () => {
+        const user = context.get("user");
+
+        if (user === undefined) throw new Error(ShieldAuthStrategyError.NotAttached);
+        if (user === null) throw new HTTPException(401, { message: ShieldAuthStrategyError.Rejected });
+        return user.id;
+      },
       ip: () =>
         context.req.header("x-real-ip") ||
         context.req.header("x-forwarded-for")?.split(",")[0]?.trim() ||

package/src/request-context.port.ts

@@ -21,6 +21,7 @@ export interface RequestContext {
 
   readonly identity: {
     userId(): UUIDType | undefined;
+    authenticatedUserId(): UUIDType;
     ip(): string | undefined;
     remoteIp(): string | undefined;
     ua(): string | undefined;
@@ -93,6 +94,10 @@ export interface HasIdentityUserId {
   readonly identity: { userId(): UUIDType | undefined };
 }
 
+export interface HasIdentityAuthenticatedUserId {
+  readonly identity: { authenticatedUserId(): UUIDType };
+}
+
 export interface HasIdentityIp {
   readonly identity: { ip(): string | undefined };
 }

package/src/shield-maintenance-hono.strategy.ts

@@ -20,7 +20,7 @@ export class ShieldMaintenanceHonoStrategy implements MiddlewareHonoPort {
 
       if (!maintenance.enabled) return next();
 
-      return c.json(maintenance.body, maintenance.code, maintenance.headers);
+      return Response.json(maintenance.body, { status: maintenance.code, headers: maintenance.headers });
     };
   }
 }

package/src/shield-security-hono.strategy.ts

@@ -1,5 +1,4 @@
 import type { MiddlewareHandler } from "hono";
-import type { ContentfulStatusCode } from "hono/utils/http-status";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 import type { SecurityPolicy } from "./security-policy.vo";
@@ -34,10 +33,10 @@ export class ShieldSecurityHonoStrategy implements MiddlewareHonoPort {
           return next();
 
         case "deny":
-          return c.text(action.reason, action.response.status as ContentfulStatusCode);
+          return new Response(action.reason, { status: action.response.status });
 
         case "mirage":
-          return c.json({}, action.response.status as ContentfulStatusCode);
+          return Response.json({}, { status: action.response.status });
 
         case "delay": {
           await this.deps.Sleeper.wait(action.duration);
@@ -47,10 +46,10 @@ export class ShieldSecurityHonoStrategy implements MiddlewareHonoPort {
               return next();
 
             case "deny":
-              return c.text(action.after.reason, action.after.response.status as ContentfulStatusCode);
+              return new Response(action.after.reason, { status: action.after.response.status });
 
             case "mirage":
-              return c.json({}, action.after.response.status as ContentfulStatusCode);
+              return Response.json({}, { status: action.after.response.status });
 
             default:
               throw new Error(ShieldSecurityHonoStrategyError.Unhandled);

package/src/smtp-port.vo.ts

@@ -1,5 +1,5 @@
-import type * as v from "valibot";
+import * as v from "valibot";
 import { Port } from "./port.vo";
 
-export const SmtpPort = Port;
+export const SmtpPort = v.pipe(Port, v.brand("SmtpPort"));
 export type SmtpPortType = v.InferOutput<typeof SmtpPort>;

package/src/translations-hono.handler.ts

@@ -22,7 +22,7 @@ export class TranslationsHonoHandler<T extends tools.LanguageType> implements Ha
       const language = c.get("language");
       const result = await this.handler.execute(language);
 
-      return c.json(result);
+      return Response.json(result);
     });
   }
 }

package/src/uuid.vo.ts

@@ -2,6 +2,6 @@ import * as v from "valibot";
 
 export const UUIDError = { Type: "uuid.type" } as const;
 
-export const UUID = v.pipe(v.string(UUIDError.Type), v.uuid(UUIDError.Type));
+export const UUID = v.pipe(v.string(UUIDError.Type), v.uuid(UUIDError.Type), v.brand("UUID"));
 
 export type UUIDType = v.InferOutput<typeof UUID>;