@getstrata/core 2.0.9 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @getstrata/core changelog
 
+## 2.1.0
+
+- refactor(starter): reuse shared config and base repositories - fix(database): await password casts before model writes - fix(database): preserve concrete model types in query results
+
 ## 2.0.9
 
 - fix(starter): remove demo credentials from public login defaults

package/dist/core/contracts/container.d.ts

@@ -1,19 +1,37 @@
+declare const serviceTokenType: unique symbol;
+/** Invariant service identity; its runtime value remains the existing string key. */
+type ServiceToken<T> = string & {
+    readonly [serviceTokenType]: (value: T) => T;
+};
+/** Prevent a typed token from falling back to an unchecked legacy overload. */
+type LegacyServiceKey = string & {
+    readonly [serviceTokenType]?: never;
+};
+declare function createServiceToken<T>(key: string): ServiceToken<T>;
 type ServiceFactory<T> = (container: ServiceContainer) => T;
 interface ServiceContainerLike {
     has(key: string): boolean;
-    resolve<T>(key: string): T;
+    resolve<T>(key: ServiceToken<T>): T;
+    resolve<T>(key: LegacyServiceKey): T;
 }
 declare class ServiceContainer implements ServiceContainerLike {
     private readonly services;
     private readonly singletonFactories;
     private readonly bindings;
-    set<T>(key: string, value: T): T;
-    singleton<T>(key: string, factory: ServiceFactory<T>): void;
-    bind<T>(key: string, factory: ServiceFactory<T>): void;
-    get<T>(key: string): T;
-    resolve<T>(key: string): T;
-    make<T>(key: string): T;
-    instance<T>(key: string, value: T): T;
+    set<T>(key: ServiceToken<T>, value: NoInfer<T>): T;
+    set<T>(key: LegacyServiceKey, value: T): T;
+    singleton<T>(key: ServiceToken<T>, factory: ServiceFactory<NoInfer<T>>): void;
+    singleton<T>(key: LegacyServiceKey, factory: ServiceFactory<T>): void;
+    bind<T>(key: ServiceToken<T>, factory: ServiceFactory<NoInfer<T>>): void;
+    bind<T>(key: LegacyServiceKey, factory: ServiceFactory<T>): void;
+    get<T>(key: ServiceToken<T>): T;
+    get<T>(key: LegacyServiceKey): T;
+    resolve<T>(key: ServiceToken<T>): T;
+    resolve<T>(key: LegacyServiceKey): T;
+    make<T>(key: ServiceToken<T>): T;
+    make<T>(key: LegacyServiceKey): T;
+    instance<T>(key: ServiceToken<T>, value: NoInfer<T>): T;
+    instance<T>(key: LegacyServiceKey, value: T): T;
     has(key: string): boolean;
 }
 interface ConfigStoreLike {
@@ -28,5 +46,5 @@ declare class ConfigStore implements ConfigStoreLike {
     require<T>(key: string): T;
     has(key: string): boolean;
 }
-export type { ConfigStoreLike, ServiceContainerLike, ServiceFactory };
-export { ConfigStore, ServiceContainer };
+export type { ConfigStoreLike, LegacyServiceKey, ServiceContainerLike, ServiceFactory, ServiceToken, };
+export { ConfigStore, createServiceToken, ServiceContainer };

package/dist/core/contracts/di.d.ts

@@ -1,6 +1,6 @@
 import type { CacheLike } from "../../types/services";
 import type { StorageManager } from "../storage/storage";
-import type { ConfigStore, ConfigStoreLike, ServiceContainer, ServiceFactory } from "./container";
+import type { ConfigStore, ConfigStoreLike, LegacyServiceKey, ServiceContainer, ServiceFactory, ServiceToken } from "./container";
 type AppRouteMap = Record<string, any>;
 type CachedJson = <T>(cacheKey: string, loader: () => Promise<T>, tags?: string[], request?: Request) => Promise<Response>;
 interface AppDependencies {
@@ -26,6 +26,7 @@ interface AppContext {
 }
 declare function getRequiredDependency<K extends keyof AppDependencies>(dependencies: Partial<AppDependencies>, key: K): AppDependencies[K];
 declare function assertAppDependenciesComplete(dependencies: MutableAppDependencies): asserts dependencies is AppDependencies;
-declare function resolveService<T>(dependencies: AppDependencies, token: string): T;
+declare function resolveService<T>(dependencies: AppDependencies, token: ServiceToken<T>): T;
+declare function resolveService<T>(dependencies: AppDependencies, token: LegacyServiceKey): T;
 export type { AppContext, AppDependencies, AppRouteMap, CachedJson, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, };
 export { assertAppDependenciesComplete, getRequiredDependency, resolveService };

package/dist/core/database/model.d.ts

@@ -13,6 +13,14 @@ interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEnt
     new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): TModel;
 }
 type AnyModel = Model<Record<string, unknown>, "id">;
+type ModelAttributes<TModel> = TModel extends {
+    toObject(): infer TRecord extends object;
+} ? TRecord : Record<string, unknown>;
+type WithModelCount<TModel, TCount extends string> = {
+    toObject(): Omit<ModelAttributes<TModel>, TCount> & Record<TCount, unknown>;
+    get<K extends keyof (Omit<ModelAttributes<TModel>, TCount> & Record<TCount, unknown>)>(key: K): (Omit<ModelAttributes<TModel>, TCount> & Record<TCount, unknown>)[K];
+} & TModel;
+type ModelQueryResult<TModel, TCounts extends string> = [TCounts] extends [never] ? TModel : WithModelCount<TModel, TCounts>;
 type RelatedRef<TRelated extends object, RelatedKey extends keyof TRelated & string> = RelatedModelClass<TRelated, RelatedKey> | string | (() => RelatedModelClass<TRelated, RelatedKey>);
 type RelationNameInput = string | readonly string[];
 type ModelObserver = {
@@ -29,10 +37,14 @@ type ModelObserver = {
 /** Alias for `hasMany("Name")` when `Name` is not `constructor.name` or `$morphClass`. */
 declare function registerModelClass(name: string, model: object): void;
 declare function hydrateValue(value: unknown, cast: CastType): unknown;
+declare function dehydrateValue(value: unknown, cast: "hashed"): Promise<unknown>;
+declare function dehydrateValue(value: unknown, cast: Exclude<CastType, "hashed">): unknown;
 declare function dehydrateValue(value: unknown, cast: CastType): unknown;
 declare function filterMassAssignable(fillable: readonly string[] | undefined, guarded: readonly string[] | true | undefined, input: LoadedAttributes): LoadedAttributes;
-declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes;
-declare class ModelQuery {
+declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate"): LoadedAttributes;
+declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "dehydrate"): Promise<LoadedAttributes>;
+declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes | Promise<LoadedAttributes>;
+declare class ModelQuery<TModel extends object = AnyModel, TCounts extends string = never> {
     private readonly modelClass;
     readonly query: RepositoryQuery<Record<string, unknown>, "id">;
     private readonly eager;
@@ -55,7 +67,7 @@ declare class ModelQuery {
         page: number;
         perPage: number;
     }): Promise<{
-        data: Array<Model<Record<string, unknown>, "id">>;
+        data: ModelQueryResult<TModel, TCounts>[];
         meta: Awaited<ReturnType<RepositoryQuery<Record<string, unknown>, "id">["paginate"]>>["meta"];
     }>;
     whereExists(sql: string, params?: readonly unknown[]): this;
@@ -73,17 +85,17 @@ declare class ModelQuery {
     withHasManyThrough(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withHasManyThrough"]>): this;
     withTrashed(): this;
     onlyTrashed(): this;
-    get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
+    get(): Promise<ModelQueryResult<TModel, TCounts>[]>;
     private hydrateRows;
-    first(): Promise<Model<Record<string, unknown>, "id"> | null>;
+    first(): Promise<ModelQueryResult<TModel, TCounts> | null>;
     count(): Promise<number>;
     pluck(column: string): Promise<unknown[]>;
     pluck(column: string, keyBy: string): Promise<Map<unknown, unknown>>;
     value(column: string): Promise<unknown>;
-    find(id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
-    findOrFail(id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
-    then(onfulfilled?: ((value: Array<Model<Record<string, unknown>, "id">>) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
-    withCount(name: string, alias?: string): this;
+    find(id: unknown): Promise<ModelQueryResult<TModel, TCounts> | null>;
+    findOrFail(id: unknown, errorFactory?: (id: unknown) => Error): Promise<ModelQueryResult<TModel, TCounts>>;
+    then(onfulfilled?: ((value: ModelQueryResult<TModel, TCounts>[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
+    withCount<TName extends string, TAlias extends string = `${TName}_count`>(name: TName, alias?: TAlias): ModelQuery<TModel, TCounts | TAlias>;
     private constrainExists;
 }
 declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -116,24 +128,40 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     protected primaryKey(): PrimaryKey;
     protected static primaryKeyField(this: object): string;
     protected static hydrateAttributes<TEntity extends object>(this: object, attributes: TEntity): TEntity;
-    protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes;
+    protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes | Promise<LoadedAttributes>;
     protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
     static boot(): void;
     static observe(this: object, observer: ModelObserver): void;
     static addGlobalScope<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, _name: string, scope: GlobalScopeFn<TEntity, PrimaryKey>): void;
     static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): BaseRepository<TEntity, PrimaryKey>;
-    static query(this: object): ModelQuery;
-    static newFromRecord(this: object, record: object, exists?: boolean): Model<Record<string, unknown>, "id">;
-    static create(this: object, attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
-    static with(this: object, ...relations: RelationNameInput[]): ModelQuery;
-    static withTrashed(this: object): ModelQuery;
-    static onlyTrashed(this: object): ModelQuery;
-    static chunk(this: object, count: number, callback: (models: Array<Model<Record<string, unknown>, "id">>) => Promise<boolean | void>): Promise<void>;
-    static cursorPaginate(this: object, options: {
+    static query<TModel extends object>(this: {
+        prototype: TModel;
+    }): ModelQuery<TModel>;
+    static newFromRecord<TModel extends object>(this: {
+        prototype: TModel;
+    }, record: object, exists?: boolean): TModel;
+    static create<TModel extends object>(this: {
+        prototype: TModel;
+    }, attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<TModel>;
+    static with<TModel extends object>(this: {
+        prototype: TModel;
+    }, ...relations: RelationNameInput[]): ModelQuery<TModel>;
+    static withTrashed<TModel extends object>(this: {
+        prototype: TModel;
+    }): ModelQuery<TModel>;
+    static onlyTrashed<TModel extends object>(this: {
+        prototype: TModel;
+    }): ModelQuery<TModel>;
+    static chunk<TModel extends object>(this: {
+        prototype: TModel;
+    }, count: number, callback: (models: TModel[]) => Promise<boolean | void>): Promise<void>;
+    static cursorPaginate<TModel extends object>(this: {
+        prototype: TModel;
+    }, options: {
         perPage: number;
         cursor?: unknown;
     }): Promise<{
-        data: Array<Model<Record<string, unknown>, "id">>;
+        data: TModel[];
         meta: {
             per_page: number;
             next_cursor: unknown;
@@ -141,22 +169,46 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
             has_more: boolean;
         };
     }>;
-    static whereHas(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
-    static has(this: object, name: string): ModelQuery;
-    static doesntHave(this: object, name: string): ModelQuery;
-    static whereDoesntHave(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
-    static find(this: object, id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
-    static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
-    static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
-    static where(this: object, where: QueryWhere<object>): ModelQuery;
+    static whereHas<TModel extends object>(this: {
+        prototype: TModel;
+    }, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery<TModel>;
+    static has<TModel extends object>(this: {
+        prototype: TModel;
+    }, name: string): ModelQuery<TModel>;
+    static doesntHave<TModel extends object>(this: {
+        prototype: TModel;
+    }, name: string): ModelQuery<TModel>;
+    static whereDoesntHave<TModel extends object>(this: {
+        prototype: TModel;
+    }, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery<TModel>;
+    static find<TModel extends object>(this: {
+        prototype: TModel;
+    }, id: unknown): Promise<TModel | null>;
+    static findOrFail<TModel extends object>(this: {
+        prototype: TModel;
+    }, id: unknown, errorFactory?: (id: unknown) => Error): Promise<TModel>;
+    static all<TModel extends object>(this: {
+        prototype: TModel;
+    }, options?: Omit<QueryOptions<object>, "where">): Promise<TModel[]>;
+    static where<TModel extends object>(this: {
+        prototype: TModel;
+    }, where: QueryWhere<object>): ModelQuery<TModel>;
     static count(this: object): Promise<number>;
     static pluck(this: object, column: string): Promise<unknown[]>;
     static pluck(this: object, column: string, keyBy: string): Promise<Map<unknown, unknown>>;
     static value(this: object, column: string): Promise<unknown>;
-    static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
-    static firstOrNew(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
-    static firstOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
-    static updateOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
+    static firstWhere<TModel extends object>(this: {
+        prototype: TModel;
+    }, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<TModel | null>;
+    static firstOrNew<TModel extends object>(this: {
+        prototype: TModel;
+    }, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<TModel>;
+    static firstOrCreate<TModel extends object>(this: {
+        prototype: TModel;
+    }, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<TModel>;
+    static updateOrCreate<TModel extends object>(this: {
+        prototype: TModel;
+    }, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<TModel>;
     save(): Promise<this>;
     update(changes: Partial<TEntity>): Promise<this>;
     delete(): Promise<boolean>;

package/dist/core/http/middleware.d.ts

@@ -1,6 +1,6 @@
 type Middleware = (request: Request, next: () => Promise<Response>) => Promise<Response>;
-type RouteHandler = (request: Request) => Response | Promise<Response>;
-declare function composeMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+type RouteHandler<TRequest extends Request = Request> = (request: TRequest) => Response | Promise<Response>;
+declare function composeMiddleware(...middleware: Middleware[]): <TRequest extends Request = Request>(handler: RouteHandler<TRequest>) => RouteHandler<TRequest>;
 declare function requestIdMiddleware(request: Request, next: () => Promise<Response>): Promise<Response>;
 declare function wrapRouteHandler<T>(handler: T, middleware: Middleware[]): T;
 declare function applyMiddlewareToRoutes<T extends Record<string, unknown>>(routes: T, middleware: Middleware[]): T;

package/dist/core/http/response.d.ts

@@ -3,7 +3,9 @@ declare function jsonResponse(data: unknown, init?: ResponseInit): Response;
 declare function createdResponse(data: unknown, init?: ResponseInit): Response;
 declare function noContentResponse(): Response;
 declare function errorResponse(error: unknown): Response;
+declare function withErrorHandling<THandler extends (request: Request) => Response | Promise<Response>>(handler: THandler): (...args: Parameters<THandler>) => Promise<Response>;
 declare function withErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
+declare function withJsonErrorHandling<THandler extends (request: Request) => Response | Promise<Response>>(handler: THandler): (...args: Parameters<THandler>) => Promise<Response>;
 declare function withJsonErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
 declare function createJsonErrorMiddleware(): Middleware;
 declare function createWebErrorMiddleware(): Middleware;

package/dist/core/http/routeMiddleware.d.ts

@@ -1,3 +1,4 @@
-import { type Middleware, type RouteHandler } from "./middleware";
-declare function withMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+import { type Middleware } from "./middleware";
+/** Middleware consumes native Request; composition preserves the handler's request subtype. */
+declare function withMiddleware(...middleware: Middleware[]): <TRequest extends Request = Request>(handler: import("./middleware").RouteHandler<TRequest>) => import("./middleware").RouteHandler<TRequest>;
 export { withMiddleware };

package/dist/entries/contracts/container.js

@@ -1,5 +1,11 @@
 // @bun
 // ../../src/core/contracts/container.ts
+function createServiceToken(key) {
+  if (!key.trim())
+    throw new Error("Service token key must not be empty.");
+  return key;
+}
+
 class ServiceContainer {
   services = new Map;
   singletonFactories = new Map;
@@ -71,5 +77,6 @@ class ConfigStore {
 }
 export {
   ConfigStore,
-  ServiceContainer
+  ServiceContainer,
+  createServiceToken
 };

package/dist/entries/database/model.js

@@ -2,6 +2,17 @@
 // ../../src/core/database/model.ts
 import { ConflictError, NotFoundError } from "@getstrata/core/errors/http";
 
+// ../../src/core/auth/password.ts
+async function hashPassword(password) {
+  return await Bun.password.hash(password, {
+    algorithm: "bcrypt",
+    cost: 12
+  });
+}
+async function verifyPassword(password, passwordHash) {
+  return await Bun.password.verify(password, passwordHash);
+}
+
 // ../../src/core/database/inflection.ts
 function singularize(word) {
   if (word.endsWith("ies") && word.length > 3) {
@@ -1624,12 +1635,14 @@ var PASSWORD_HASH_PATTERN = /^\$(?:2[aby]?|argon2(?:i|d|id)?)\$/;
 function isAlreadyHashed(value) {
   return PASSWORD_HASH_PATTERN.test(value);
 }
-function hashCastValue(value) {
+async function hashCastValue(value) {
+  if (value === null || value === undefined)
+    return value;
   const plain = String(value);
   if (isAlreadyHashed(plain)) {
     return plain;
   }
-  return Bun.password.hashSync(plain, { algorithm: "bcrypt", cost: 12 });
+  return await hashPassword(plain);
 }
 function hydrateValue(value, cast) {
   if (value === null || value === undefined) {
@@ -1654,6 +1667,8 @@ function hydrateValue(value, cast) {
   }
 }
 function dehydrateValue(value, cast) {
+  if (cast === "hashed")
+    return hashCastValue(value);
   if (value === null || value === undefined) {
     return value;
   }
@@ -1669,8 +1684,6 @@ function dehydrateValue(value, cast) {
     case "integer":
     case "int":
       return value === "" ? null : Number(value);
-    case "hashed":
-      return hashCastValue(value);
     default:
       return value;
   }
@@ -1691,17 +1704,25 @@ function filterMassAssignable(fillable, guarded, input) {
   return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
 }
 function applyCasts(values, casts, direction) {
-  if (Object.keys(casts).length === 0) {
-    return values;
+  const entries = Object.entries(casts);
+  if (entries.length === 0) {
+    return direction === "hydrate" ? values : Promise.resolve(values);
   }
   const result = { ...values };
-  const castFn = direction === "hydrate" ? hydrateValue : dehydrateValue;
-  for (const [key, cast] of Object.entries(casts)) {
-    if (key in result && cast) {
-      result[key] = castFn(result[key], cast);
+  if (direction === "hydrate") {
+    for (const [key, cast] of entries) {
+      if (key in result && cast)
+        result[key] = hydrateValue(result[key], cast);
     }
+    return result;
   }
-  return result;
+  return (async () => {
+    for (const [key, cast] of entries) {
+      if (key in result && cast)
+        result[key] = await dehydrateValue(result[key], cast);
+    }
+    return result;
+  })();
 }
 function castPluckedValue(modelClass, column, value) {
   const cast = modelStatics(modelClass).$casts?.[column];
@@ -2096,7 +2117,7 @@ class Model {
       ...forced
     };
     const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = statics.dehydrateAttributes(withTimestamps);
+    const payload = await statics.dehydrateAttributes(withTimestamps);
     const pending = statics.newFromRecord({ ...payload }, false);
     if (await runObservers(pending, "saving") === false) {
       throw new Error(`${this.name}.create() was cancelled by an observer.`);
@@ -2237,7 +2258,7 @@ class Model {
       return this;
     }
     if (updating) {
-      const changes = applyTimestampsOnUpdate(table.columns, applyCasts(this.attributes, casts, "dehydrate"), timestamps);
+      const changes = applyTimestampsOnUpdate(table.columns, await applyCasts(this.attributes, casts, "dehydrate"), timestamps);
       const record = await this.repository.updateByIdOrThrow(this.id, changes);
       this.attributes = ModelClass.hydrateAttributes(record);
       await runObservers(this, "updated");
@@ -2246,7 +2267,7 @@ class Model {
     }
     const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
     const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = ModelClass.dehydrateAttributes(withTimestamps);
+    const payload = await ModelClass.dehydrateAttributes(withTimestamps);
     const record = await this.repository.create(payload);
     this.attributes = ModelClass.hydrateAttributes(record);
     this._exists = true;

package/dist/entries/http/routeMiddleware.js

@@ -62,10 +62,7 @@ function composeMiddleware(...middleware) {
 
 // ../../src/core/http/routeMiddleware.ts
 function withMiddleware(...middleware) {
-  const wrap = composeMiddleware(...middleware);
-  return (handler) => {
-    return wrap(handler);
-  };
+  return composeMiddleware(...middleware);
 }
 export {
   withMiddleware

package/dist/framework/public-api.d.ts

@@ -29,7 +29,7 @@ export { createTokenAbilityChecker } from "../core/auth/tokenAbilityChecker.ts";
 export { type CacheDriver, type CreateCacheStoreOptions, createCacheStore, } from "../core/cache/createCacheStore.ts";
 export { default as CacheRepository } from "../core/cache/repository.ts";
 export { CACHE_TAGS } from "../core/cache/tags.ts";
-export { ConfigStore, ServiceContainer } from "../core/contracts/container.ts";
+export { ConfigStore, createServiceToken, ServiceContainer, type ServiceToken, } from "../core/contracts/container.ts";
 export type { ServiceProvider } from "../core/contracts/di.ts";
 export { resolveService } from "../core/contracts/di.ts";
 export type { DatabaseConnection } from "../core/database/baseRepository.ts";

package/dist/index.js

@@ -1124,6 +1124,12 @@ function readBasicCredentials(request) {
 }
 
 // ../../src/core/auth/password.ts
+async function hashPassword(password) {
+  return await Bun.password.hash(password, {
+    algorithm: "bcrypt",
+    cost: 12
+  });
+}
 async function verifyPassword(password, passwordHash) {
   return await Bun.password.verify(password, passwordHash);
 }
@@ -3760,6 +3766,12 @@ var CACHE_TAGS = {
   offers: "offers"
 };
 // ../../src/core/contracts/container.ts
+function createServiceToken(key) {
+  if (!key.trim())
+    throw new Error("Service token key must not be empty.");
+  return key;
+}
+
 class ServiceContainer {
   services = new Map;
   singletonFactories = new Map;
@@ -6604,12 +6616,14 @@ var PASSWORD_HASH_PATTERN = /^\$(?:2[aby]?|argon2(?:i|d|id)?)\$/;
 function isAlreadyHashed(value) {
   return PASSWORD_HASH_PATTERN.test(value);
 }
-function hashCastValue(value) {
+async function hashCastValue(value) {
+  if (value === null || value === undefined)
+    return value;
   const plain = String(value);
   if (isAlreadyHashed(plain)) {
     return plain;
   }
-  return Bun.password.hashSync(plain, { algorithm: "bcrypt", cost: 12 });
+  return await hashPassword(plain);
 }
 function hydrateValue(value, cast) {
   if (value === null || value === undefined) {
@@ -6634,6 +6648,8 @@ function hydrateValue(value, cast) {
   }
 }
 function dehydrateValue(value, cast) {
+  if (cast === "hashed")
+    return hashCastValue(value);
   if (value === null || value === undefined) {
     return value;
   }
@@ -6649,8 +6665,6 @@ function dehydrateValue(value, cast) {
     case "integer":
     case "int":
       return value === "" ? null : Number(value);
-    case "hashed":
-      return hashCastValue(value);
     default:
       return value;
   }
@@ -6671,17 +6685,25 @@ function filterMassAssignable(fillable, guarded, input) {
   return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
 }
 function applyCasts(values, casts, direction) {
-  if (Object.keys(casts).length === 0) {
-    return values;
+  const entries = Object.entries(casts);
+  if (entries.length === 0) {
+    return direction === "hydrate" ? values : Promise.resolve(values);
   }
   const result = { ...values };
-  const castFn = direction === "hydrate" ? hydrateValue : dehydrateValue;
-  for (const [key, cast] of Object.entries(casts)) {
-    if (key in result && cast) {
-      result[key] = castFn(result[key], cast);
+  if (direction === "hydrate") {
+    for (const [key, cast] of entries) {
+      if (key in result && cast)
+        result[key] = hydrateValue(result[key], cast);
     }
+    return result;
   }
-  return result;
+  return (async () => {
+    for (const [key, cast] of entries) {
+      if (key in result && cast)
+        result[key] = await dehydrateValue(result[key], cast);
+    }
+    return result;
+  })();
 }
 function castPluckedValue(modelClass, column, value) {
   const cast = modelStatics(modelClass).$casts?.[column];
@@ -7076,7 +7098,7 @@ class Model {
       ...forced
     };
     const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = statics.dehydrateAttributes(withTimestamps);
+    const payload = await statics.dehydrateAttributes(withTimestamps);
     const pending = statics.newFromRecord({ ...payload }, false);
     if (await runObservers(pending, "saving") === false) {
       throw new Error(`${this.name}.create() was cancelled by an observer.`);
@@ -7217,7 +7239,7 @@ class Model {
       return this;
     }
     if (updating) {
-      const changes = applyTimestampsOnUpdate(table.columns, applyCasts(this.attributes, casts, "dehydrate"), timestamps);
+      const changes = applyTimestampsOnUpdate(table.columns, await applyCasts(this.attributes, casts, "dehydrate"), timestamps);
       const record = await this.repository.updateByIdOrThrow(this.id, changes);
       this.attributes = ModelClass.hydrateAttributes(record);
       await runObservers(this, "updated");
@@ -7226,7 +7248,7 @@ class Model {
     }
     const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
     const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = ModelClass.dehydrateAttributes(withTimestamps);
+    const payload = await ModelClass.dehydrateAttributes(withTimestamps);
     const record = await this.repository.create(payload);
     this.attributes = ModelClass.hydrateAttributes(record);
     this._exists = true;
@@ -10617,10 +10639,7 @@ function getRouteParams(request) {
 }
 // ../../src/core/http/routeMiddleware.ts
 function withMiddleware(...middleware) {
-  const wrap = composeMiddleware(...middleware);
-  return (handler) => {
-    return wrap(handler);
-  };
+  return composeMiddleware(...middleware);
 }
 // ../../src/core/http/routeModelBinding.ts
 function bindRouteModel(param, resolver, handler) {
@@ -13179,6 +13198,7 @@ export {
   createScimAuthMiddleware,
   createScimThrottleMiddleware,
   createSecurityHeadersMiddleware,
+  createServiceToken,
   createSqliteConnection,
   createStorageDriver,
   createTenantMiddleware,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",