@getstrata/core 0.3.0 → 0.3.2

package/dist/bootstrap/config.d.ts

@@ -9,6 +9,7 @@ declare const CORE_CACHE_TOKEN = "core.cache";
 declare const CORE_QUEUE_TOKEN = "core.queue";
 declare const CORE_POLICY_GATE_TOKEN = "core.policyGate";
 declare const CORE_AUTH_TOKEN = "core.auth";
+declare const CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
 declare const AUTH_DEV_HEADERS_CONFIG_KEY = "auth.allowDevHeaders";
 declare const DEFAULT_APP_PORT = 3000;
 declare const DEFAULT_CACHE_TTL_MS = 3600000;
@@ -16,4 +17,4 @@ declare const DEFAULT_CACHE_MAX_ENTRIES = 100;
 declare const DEFAULT_CACHE_DRIVER = "array";
 declare const DEFAULT_API_TOKEN = "";
 declare const DEFAULT_QUEUE_DRIVER = "sync";
-export { APP_PORT_CONFIG_KEY, AUTH_DEV_HEADERS_CONFIG_KEY, CACHE_DRIVER_CONFIG_KEY, CACHE_MAX_ENTRIES_CONFIG_KEY, CACHE_TTL_MS_CONFIG_KEY, CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_API_TOKEN, DEFAULT_APP_PORT, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_TTL_MS, DEFAULT_QUEUE_DRIVER, REDIS_URL_CONFIG_KEY, };
+export { APP_PORT_CONFIG_KEY, AUTH_DEV_HEADERS_CONFIG_KEY, CACHE_DRIVER_CONFIG_KEY, CACHE_MAX_ENTRIES_CONFIG_KEY, CACHE_TTL_MS_CONFIG_KEY, CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_API_TOKEN, DEFAULT_APP_PORT, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_TTL_MS, DEFAULT_QUEUE_DRIVER, REDIS_URL_CONFIG_KEY, };

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

@@ -1,5 +1,6 @@
 import { type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
 interface DatabaseConnection {
@@ -27,6 +28,8 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     withConnection(connection: DatabaseConnection): this;
+    getConnection(): DatabaseConnection;
+    query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
     protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
@@ -36,9 +39,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         value: TEntity[K] | null;
         count: number;
     }>>;
-    protected findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    protected loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
-    protected loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
+    findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
+    loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

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

@@ -5,6 +5,7 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, } from "./query.ts";
 export type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
 export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "./relationships.ts";
+export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
 export { runInTransaction } from "./transaction.ts";

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

@@ -0,0 +1,20 @@
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type LoadedRow = Record<string, unknown>;
+declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    private readonly repository;
+    private whereClause;
+    private queryOptions;
+    private readonly eagerLoads;
+    constructor(repository: BaseRepository<TEntity, PrimaryKey>, whereClause?: QueryWhere<TEntity>, queryOptions?: Omit<QueryOptions<TEntity>, "where">);
+    where(where: QueryWhere<TEntity>): this;
+    orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
+    limit(limit: number): this;
+    withHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): this;
+    get(): Promise<Array<TEntity & LoadedRow>>;
+    first(): Promise<(TEntity & LoadedRow) | null>;
+    private attach;
+}
+export { RepositoryQuery };

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

@@ -9,8 +9,13 @@ export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext";
 export { Policy } from "../core/auth/policy";
 export { default as CacheRepository } from "../core/cache/repository";
 export { CACHE_TAGS } from "../core/cache/tags";
+export type { DatabaseConnection } from "../core/database/baseRepository";
 export { default as BaseRepository } from "../core/database/baseRepository";
+export type { BelongsToRelation, HasManyRelation } from "../core/database/relationships";
+export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "../core/database/relationships";
+export { RepositoryQuery } from "../core/database/repositoryQuery";
 export { defineTable } from "../core/database/table";
+export type { QueryOptions, QueryOrder, QueryWhere, } from "../core/database/types";
 export { BadRequestError, ConflictError, ForbiddenError, NotFoundError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "../core/errors/http";
 export { EventBus } from "../core/events/eventBus";
 export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades";

package/dist/index.js

@@ -699,6 +699,18 @@ function buildDeleteByIdQuery(table, id) {
 }
 
 // ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -730,6 +742,86 @@ function indexBelongsToRelation(children, parents, relation) {
   return result;
 }
 
+// ../../src/core/database/repositoryQuery.ts
+class RepositoryQuery {
+  repository;
+  whereClause;
+  queryOptions;
+  eagerLoads = [];
+  constructor(repository, whereClause = {}, queryOptions = {}) {
+    this.repository = repository;
+    this.whereClause = whereClause;
+    this.queryOptions = queryOptions;
+  }
+  where(where) {
+    this.whereClause = { ...this.whereClause, ...where };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.queryOptions = { ...this.queryOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.queryOptions = { ...this.queryOptions, limit };
+    return this;
+  }
+  withHasMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withBelongsTo(as, relation, parentRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsTo",
+      as,
+      relation,
+      repository: parentRepository,
+      options
+    });
+    return this;
+  }
+  async get() {
+    const rows = await this.repository.findAll({
+      ...this.queryOptions,
+      where: this.whereClause
+    });
+    return await this.attach(rows);
+  }
+  async first() {
+    const rows = await this.get();
+    return rows[0] ?? null;
+  }
+  async attach(rows) {
+    if (rows.length === 0 || this.eagerLoads.length === 0) {
+      return rows.map((row) => ({ ...row }));
+    }
+    let result = rows.map((row) => ({ ...row }));
+    for (const load of this.eagerLoads) {
+      if (load.kind === "hasMany") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
+      const relation = load.relation;
+      const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
+      result = result.map((row) => ({
+        ...row,
+        [load.as]: grouped.get(row[relation.foreignKey])
+      }));
+    }
+    return result;
+  }
+}
+
 // ../../src/core/database/baseRepository.ts
 class BaseRepository {
   table;
@@ -866,6 +958,12 @@ class BaseRepository {
     clone.connection = connection;
     return clone;
   }
+  getConnection() {
+    return this.connection;
+  }
+  query(where = {}) {
+    return new RepositoryQuery(this, where);
+  }
   async findWhere(where, options = {}) {
     return await this.findAll({ ...options, where });
   }
@@ -2163,6 +2261,9 @@ export {
   log,
   jsonResponse,
   isEtagEnabled,
+  indexHasManyRelation,
+  indexBelongsToRelation,
+  hasMany,
   events,
   etagFromResource,
   defineTable,
@@ -2172,6 +2273,7 @@ export {
   createMetricsMiddleware,
   config,
   cache,
+  belongsTo,
   auth,
   assertIfMatch,
   WebFormRequest,
@@ -2181,6 +2283,7 @@ export {
   SyncQueue,
   StorageManager,
   ServiceContainer,
+  RepositoryQuery,
   PrometheusRegistry,
   PreconditionFailedError,
   Policy,

package/dist/modules/user/provider.d.ts

@@ -1,7 +1,7 @@
 import type { ServiceProvider } from "../../bootstrap/contracts";
 declare const userRepositoryToken = "user.repository";
 declare const apiTokenRepositoryToken = "user.apiTokenRepository";
-declare const tokenServiceToken = "user.tokenService";
+declare const tokenServiceToken = "core.tokenService";
 declare const authServiceToken = "user.authService";
 declare const oauthIdentityRepositoryToken = "user.oauthIdentityRepository";
 declare const notificationRepositoryToken = "user.notificationRepository";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",