@getstrata/core 0.3.9 → 0.5.0

package/dist/core/database/seeders/types.d.ts

@@ -0,0 +1,8 @@
+interface SeederDatabase {
+    unsafe(query: string): Promise<unknown>;
+}
+interface Seeder {
+    name: string;
+    run(db: SeederDatabase): Promise<void>;
+}
+export type { Seeder, SeederDatabase };

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

@@ -8,14 +8,47 @@ type QueryOperator = {
     lt?: DatabaseComparable;
     lte?: DatabaseComparable;
     isNull?: boolean;
+    ilike?: string;
+    tsMatch?: string;
 };
 type QueryFilterValue = DatabaseScalar | readonly DatabaseScalar[] | QueryOperator;
-type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>>;
+type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>> & Partial<Record<string, QueryFilterValue>>;
 type QueryOrder<TEntity> = {
     column: keyof TEntity & string;
     direction?: "ASC" | "DESC" | "asc" | "desc";
 };
 type QueryOrderShorthand<TEntity> = Partial<Record<keyof TEntity & string, "ASC" | "DESC" | "asc" | "desc">>;
+type QueryJoinOn = {
+    left: {
+        table: string;
+        column: string;
+    };
+    right: {
+        table: string;
+        column: string;
+    };
+};
+type QueryJoin = {
+    type: "inner" | "left";
+    table: string;
+    on: QueryJoinOn[];
+};
+type QuerySelectItem = {
+    kind: "column";
+    table: string;
+    column: string;
+    as?: string;
+} | {
+    kind: "literalText";
+    value: string;
+    as: string;
+} | {
+    kind: "tsRank";
+    table: string;
+    column: string;
+    query: string;
+    as: string;
+};
 interface QueryOptions<TEntity> {
     where?: QueryWhere<TEntity>;
     orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
@@ -23,7 +56,11 @@ interface QueryOptions<TEntity> {
     offset?: number;
     withTrashed?: boolean;
     onlyTrashed?: boolean;
+    joins?: QueryJoin[];
+    groupBy?: string | string[];
+    having?: QueryWhere<TEntity>;
+    select?: QuerySelectItem[];
 }
 type MutationValues<TEntity> = Partial<TEntity>;
 type UpdateValues<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> = Partial<Omit<TEntity, PrimaryKey>>;
-export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryOperator, QueryOptions, QueryOrder, QueryWhere, UpdateValues, };
+export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };

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

@@ -0,0 +1,17 @@
+import type { QueryWhere } from "./types.ts";
+type WhereNode<TEntity extends object> = {
+    kind: "and" | "or";
+    where: QueryWhere<TEntity>;
+} | {
+    kind: "and" | "or";
+    group: WhereNode<TEntity>[];
+};
+declare class WhereBuilder<TEntity extends object> {
+    readonly nodes: WhereNode<TEntity>[];
+    where(where: QueryWhere<TEntity>): this;
+    orWhere(where: QueryWhere<TEntity>): this;
+    whereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
+    orWhereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
+}
+export type { WhereNode };
+export { WhereBuilder };

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

@@ -13,7 +13,7 @@ export { createRequireAuthMiddleware } from "./requireAuthMiddleware";
 export { serializeDate, toPaginatedResourceCollection, toResourceCollection } from "./resources";
 export { withMiddleware } from "./routeMiddleware";
 export { bindRouteModel } from "./routeModelBinding";
-export { securedBindRouteModel } from "./securedRouteModelBinding";
+export { securedBindRouteModel, securedBindRouteModelByKey, } from "./securedRouteModelBinding";
 export { buildRequestCacheKey, expectObject, getQueryParams, parseJsonBody, parseOptionalBooleanQueryParam, parseOptionalEnumQueryParam, parseOptionalPositiveIntQueryParam, parsePositiveIntParam, readOptionalEnum, readOptionalPositiveInt, readOptionalString, readRequiredEnum, readRequiredPositiveInt, readRequiredString, } from "./validation";
 declare function jsonResponse(data: unknown, init?: ResponseInit): Response;
 declare function createdResponse(data: unknown, init?: ResponseInit): Response;

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

@@ -6,5 +6,6 @@ interface RouteModelAuthorization {
     requireIfMatch?: boolean;
 }
 declare function securedBindRouteModel<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (id: number, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+declare function securedBindRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
 export type { RouteModelAuthorization };
-export { securedBindRouteModel };
+export { securedBindRouteModel, securedBindRouteModelByKey };

package/dist/core/lifecycle/gracefulShutdown.d.ts

@@ -0,0 +1,6 @@
+type ShutdownHandler = () => void | Promise<void>;
+declare function registerShutdownHandler(name: string, handler: ShutdownHandler): () => void;
+declare function runGracefulShutdown(signal: string): Promise<void>;
+declare function installGracefulShutdownSignals(signals?: NodeJS.Signals[]): void;
+declare function resetGracefulShutdownForTests(): void;
+export { installGracefulShutdownSignals, registerShutdownHandler, resetGracefulShutdownForTests, runGracefulShutdown, };

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

@@ -8,10 +8,20 @@ interface PaginatedResult<T> {
     data: T[];
     meta: PaginationMeta;
 }
+interface CursorPaginationMeta<Cursor = unknown> {
+    per_page: number;
+    next_cursor: Cursor | null;
+    prev_cursor: Cursor | null;
+    has_more: boolean;
+}
+interface CursorPaginatedResult<T, Cursor = unknown> {
+    data: T[];
+    meta: CursorPaginationMeta<Cursor>;
+}
 declare function buildPaginationMeta(input: {
     page: number;
     perPage: number;
     total: number;
 }): PaginationMeta;
-export type { PaginatedResult, PaginationMeta };
+export type { CursorPaginatedResult, CursorPaginationMeta, PaginatedResult, PaginationMeta };
 export { buildPaginationMeta };

package/dist/core/queue/failedJobRepository.d.ts

@@ -0,0 +1,6 @@
+import { BaseRepository } from "../database";
+import type { FailedJobRecord } from "./types";
+declare class FailedJobRepository extends BaseRepository<FailedJobRecord, "id"> {
+    constructor();
+}
+export default FailedJobRepository;

package/dist/core/queue/failedJobService.d.ts

@@ -0,0 +1,15 @@
+import type FailedJobRepository from "./failedJobRepository";
+import type { FailedJobRecord } from "./types";
+declare class FailedJobService {
+    private readonly repository;
+    constructor(repository: FailedJobRepository);
+    recordFailure(input: {
+        jobName: string;
+        payload: Record<string, unknown>;
+        exception: string;
+    }): Promise<FailedJobRecord>;
+    listRecent(limit?: number): Promise<FailedJobRecord[]>;
+    retry(id: number): Promise<FailedJobRecord>;
+    flush(): Promise<number>;
+}
+export default FailedJobService;

package/dist/core/queue/failedJobTable.d.ts

@@ -0,0 +1,3 @@
+import type { FailedJobRecord } from "./types";
+declare const failedJobTable: import("../database").TableDefinition<FailedJobRecord, "id">;
+export { failedJobTable };

package/dist/core/queue/jobRegistry.d.ts

@@ -0,0 +1,14 @@
+import type { Job } from "./index";
+type JobFactory = () => Job;
+declare class JobRegistry {
+    constructor();
+    private readonly factories;
+    private readonly instances;
+    register(name: string, factory: JobFactory): void;
+    resolveName(job: Job): string | undefined;
+    track(name: string, job: Job): Job;
+    create(name: string): Job | undefined;
+    names(): string[];
+}
+declare const jobRegistry: JobRegistry;
+export { JobRegistry, jobRegistry };

package/dist/core/queue/jobRunner.d.ts

@@ -0,0 +1,9 @@
+import type FailedJobService from "./failedJobService";
+interface QueueJobEnvelope {
+    name: string;
+    payload: Record<string, unknown>;
+    attempts?: number;
+}
+declare function runQueueJob(envelope: QueueJobEnvelope, failedJobs: FailedJobService): Promise<void>;
+export type { QueueJobEnvelope };
+export { runQueueJob };

package/dist/core/queue/publicQueue.d.ts

@@ -0,0 +1,15 @@
+import FailedJobRepository from "./failedJobRepository.ts";
+import FailedJobService from "./failedJobService.ts";
+import type { Job, Queue } from "./index.ts";
+import { jobRegistry } from "./jobRegistry.ts";
+import { QueueWorker, RedisQueue } from "./redisQueue.ts";
+import { ResilientQueue } from "./resilientQueue.ts";
+declare function createFailedJobService(): FailedJobService;
+declare function createTrackedJob<TPayload extends object>(name: string, job: Job<TPayload>): Job<TPayload>;
+declare function createProductionQueue(driver: "sync" | "async" | "redis", options?: {
+    redisUrl?: string;
+    failedJobs?: FailedJobService;
+    registerJobs?: () => void;
+}): Queue;
+declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, };

package/dist/core/queue/redisQueue.d.ts

@@ -0,0 +1,29 @@
+import type FailedJobService from "./failedJobService";
+import type { Job, Queue, QueuePriority } from "./index";
+import { type QueueJobEnvelope } from "./jobRunner";
+declare const QUEUE_LIST_KEY = "workhub:queue:default";
+declare const QUEUE_HIGH_KEY = "workhub:queue:high";
+declare const QUEUE_LOW_KEY = "workhub:queue:low";
+declare function queueKeyForPriority(priority?: QueuePriority): string;
+declare function parseQueueJobEnvelope(rawPayload: string): QueueJobEnvelope | null;
+declare class RedisQueue implements Queue {
+    private readonly client;
+    constructor(redisUrl: string);
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class QueueWorker {
+    private readonly failedJobs;
+    private readonly timeoutSeconds;
+    private running;
+    private stopping;
+    private readonly client;
+    constructor(redisUrl: string, failedJobs: FailedJobService, timeoutSeconds?: number);
+    requestStop(): void;
+    isRunning(): boolean;
+    processNext(): Promise<boolean>;
+    run(): Promise<void>;
+    close(): void;
+}
+declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
+export type { QueueJobEnvelope };
+export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueKeyForPriority, RedisQueue, };

package/dist/core/queue/resilientQueue.d.ts

@@ -0,0 +1,9 @@
+import type FailedJobService from "./failedJobService";
+import type { Job, Queue } from "./index";
+declare class ResilientQueue implements Queue {
+    private readonly failedJobs;
+    private readonly asyncDispatch;
+    constructor(failedJobs: FailedJobService, asyncDispatch?: boolean);
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+export { ResilientQueue };

package/dist/core/queue/types.d.ts

@@ -0,0 +1,8 @@
+interface FailedJobRecord {
+    id: number;
+    job_name: string;
+    payload: Record<string, unknown>;
+    exception: string;
+    failed_at: Date;
+}
+export type { FailedJobRecord };

package/dist/core/scheduler/schedule.d.ts

@@ -0,0 +1,15 @@
+type ScheduledTask = {
+    expression: string;
+    name: string;
+    run: () => void | Promise<void>;
+};
+declare class Schedule {
+    private readonly tasks;
+    command(expression: string, name: string, run: () => void | Promise<void>): this;
+    dueTasks(now?: Date): ScheduledTask[];
+    tasksList(): ScheduledTask[];
+}
+declare const appSchedule: Schedule;
+declare function runDueScheduledTasks(schedule?: Schedule, now?: Date): Promise<number>;
+export type { ScheduledTask };
+export { appSchedule, runDueScheduledTasks, Schedule };

package/dist/entries/auth/accessControl.js

@@ -0,0 +1,113 @@
+// @bun
+// ../../src/core/errors/http.ts
+class HttpError extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.name = new.target.name;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+class BadRequestError extends HttpError {
+  constructor(message = "Bad Request", details) {
+    super(400, message, details);
+  }
+}
+
+class NotFoundError extends HttpError {
+  constructor(message = "Not Found", details) {
+    super(404, message, details);
+  }
+}
+
+class ConflictError extends HttpError {
+  constructor(message = "Conflict", details) {
+    super(409, message, details);
+  }
+}
+
+class UnprocessableEntityError extends HttpError {
+  constructor(message = "Unprocessable Entity", details) {
+    super(422, message, details);
+  }
+}
+
+class ValidationError extends HttpError {
+  constructor(message = "Validation failed", details) {
+    super(422, message, details);
+  }
+}
+
+class ForbiddenError extends HttpError {
+  constructor(message = "Forbidden", details) {
+    super(403, message, details);
+  }
+}
+
+class UnauthorizedError extends HttpError {
+  constructor(message = "Unauthorized", details) {
+    super(401, message, details);
+  }
+}
+
+class PayloadTooLargeError extends HttpError {
+  constructor(message = "Payload Too Large", details) {
+    super(413, message, details);
+  }
+}
+
+class PreconditionFailedError extends HttpError {
+  constructor(message = "Precondition Failed", details) {
+    super(412, message, details);
+  }
+}
+
+// ../../src/core/auth/authContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authContext = new AsyncLocalStorage;
+function runWithAuthUser(user, callback) {
+  return authContext.run(user, callback);
+}
+function currentAuthUser() {
+  return authContext.getStore() ?? null;
+}
+
+// ../../src/core/auth/accessControl.ts
+var ROLE_RANK = {
+  member: 1,
+  admin: 2,
+  owner: 3
+};
+function isGlobalAdmin(user) {
+  return user?.role === "admin";
+}
+function hasMinimumOrgRole(role, minimum) {
+  if (!role) {
+    return false;
+  }
+  return ROLE_RANK[role] >= ROLE_RANK[minimum];
+}
+function requireAuthenticatedUser() {
+  const user = currentAuthUser();
+  if (!user) {
+    throw new ForbiddenError("Authentication required.");
+  }
+  return user;
+}
+function resolveUserId(user) {
+  const userId = typeof user.id === "number" ? user.id : Number(user.id);
+  if (!Number.isInteger(userId) || userId <= 0) {
+    throw new ForbiddenError("Invalid authenticated user.");
+  }
+  return userId;
+}
+export {
+  resolveUserId,
+  requireAuthenticatedUser,
+  isGlobalAdmin,
+  hasMinimumOrgRole,
+  ROLE_RANK
+};

package/dist/entries/auth/authContext.js

@@ -0,0 +1,15 @@
+// @bun
+// ../../src/core/auth/authContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authContext = new AsyncLocalStorage;
+function runWithAuthUser(user, callback) {
+  return authContext.run(user, callback);
+}
+function currentAuthUser() {
+  return authContext.getStore() ?? null;
+}
+export {
+  runWithAuthUser,
+  currentAuthUser,
+  authContext
+};