@getstrata/core 0.5.14 → 0.5.16

package/dist/bootstrap/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { StorageManager } from "../core/storage/storage";
 import type { CacheLike } from "../types/services";
 type CachedJson = <T>(cacheKey: string, loader: () => Promise<T>, tags?: string[], request?: Request) => Promise<Response>;
 type AppRouteMap = Record<string, any>;
@@ -23,6 +24,7 @@ declare class ConfigStore {
 interface AppDependencies {
     container: ServiceContainer;
     cache: CacheLike;
+    storage: StorageManager;
 }
 type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
 interface ProviderContext {

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

@@ -0,0 +1,11 @@
+import type { Policy } from "../../core/auth/policy";
+import type { RouteRequest } from "../../core/http/route";
+interface RouteModelAuthorization {
+    resource: string;
+    action: keyof Policy;
+    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, securedBindRouteModelByKey };

package/dist/core/auth/membershipService.d.ts

@@ -1,7 +1,10 @@
 import type { OrganizationMemberRole } from "../../modules/organization/memberTypes";
 import { type AuthUser } from "./authContext";
+import { membershipRepository as defaultMembershipRepository } from "./membershipContext";
+type MembershipRepositoryLike = Pick<typeof defaultMembershipRepository, "listForUser" | "findMembership" | "listForOrganization" | "addMember" | "removeMember">;
 declare class MembershipService {
-    constructor();
+    private readonly members;
+    constructor(members?: MembershipRepositoryLike);
     listOrganizationIdsForUser(userId: number): Promise<number[]>;
     getOrgRole(userId: number, organizationId: number): Promise<OrganizationMemberRole | null>;
     requireOrgAccess(organizationId: number, minimumRole?: OrganizationMemberRole, user?: AuthUser | null): Promise<OrganizationMemberRole>;
@@ -16,5 +19,6 @@ declare class MembershipService {
     removeMember(organizationId: number, userId: number): Promise<boolean>;
 }
 declare function resolveMembershipService(): MembershipService;
+export type { MembershipRepositoryLike };
 export default MembershipService;
 export { resolveMembershipService };

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

@@ -9,6 +9,11 @@ type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
 };
 interface DatabaseConnection {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+    begin?<T>(callback: (transaction: DatabaseConnection) => Promise<T>): Promise<T>;
+    close?(): Promise<void>;
+}
+interface SqlDatabaseConnection extends DatabaseConnection {
+    (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
 }
 type ErrorFactory<TValue> = (value: TValue) => Error;
 declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -59,4 +64,4 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
 }
 export default BaseRepository;
-export type { DatabaseConnection };
+export type { DatabaseConnection, SqlDatabaseConnection };

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

@@ -3,5 +3,6 @@ type ActiveDatabaseHandle = {
 };
 declare function runWithDatabaseConnection<T>(connection: ActiveDatabaseHandle, callback: () => T | Promise<T>): T | Promise<T>;
 declare function getActiveDatabaseConnection<T extends ActiveDatabaseHandle>(fallback: T): T;
+declare function hasActiveDatabaseConnection(): boolean;
 export type { ActiveDatabaseHandle };
-export { getActiveDatabaseConnection, runWithDatabaseConnection };
+export { getActiveDatabaseConnection, hasActiveDatabaseConnection, runWithDatabaseConnection };

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

@@ -0,0 +1,6 @@
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function registerDefaultDatabasePool(connection: SqlDatabaseConnection): void;
+declare function getDefaultDatabasePool(): SqlDatabaseConnection;
+declare function getDefaultDatabaseQuery(): SqlDatabaseConnection;
+declare function resetDefaultDatabasePoolForTests(): void;
+export { getDefaultDatabasePool, getDefaultDatabaseQuery, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };

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

@@ -0,0 +1,3 @@
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function createDatabaseQueryProxy(pool: SqlDatabaseConnection): SqlDatabaseConnection;
+export { createDatabaseQueryProxy };

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

@@ -1,4 +1,4 @@
-import type { DatabaseConnection } from "./baseRepository";
-declare function resolveRepositoryConnection(): DatabaseConnection;
-declare const repositoryConnection: DatabaseConnection;
+import type { SqlDatabaseConnection } from "./baseRepository";
+declare function resolveRepositoryConnection(): SqlDatabaseConnection;
+declare const repositoryConnection: SqlDatabaseConnection;
 export { repositoryConnection, resolveRepositoryConnection };

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

@@ -1,11 +1,2 @@
-import type { Policy } from "../auth/policy";
-import type { RouteRequest } from "./route";
-interface RouteModelAuthorization {
-    resource: string;
-    action: keyof Policy;
-    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, securedBindRouteModelByKey };
+export type { RouteModelAuthorization } from "../../bootstrap/http/securedRouteModelBinding.ts";
+export { securedBindRouteModel, securedBindRouteModelByKey, } from "../../bootstrap/http/securedRouteModelBinding.ts";

package/dist/core/jobs/dispatchWebhookJob.d.ts

@@ -5,7 +5,6 @@ interface DispatchWebhookPayload {
     payload: Record<string, unknown>;
 }
 declare class DispatchWebhookJob extends Job<DispatchWebhookPayload> {
-    constructor();
     readonly maxAttempts = 3;
     readonly backoffMs = 2000;
     handle(payload: DispatchWebhookPayload): Promise<void>;

package/dist/core/security/safeFetch.d.ts

@@ -2,6 +2,8 @@ declare const DEFAULT_FETCH_TIMEOUT_MS = 10000;
 interface SafeFetchOptions {
     timeoutMs?: number;
     maxRedirects?: number;
+    allowHttp?: boolean;
+    resolveDns?: boolean;
 }
 declare function safeFetch(input: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;
 export type { SafeFetchOptions };

package/dist/core/security/safeUrl.d.ts

@@ -1,5 +1,20 @@
+type DnsLookupResult = {
+    address: string;
+    family: number;
+};
+type DnsLookup = (hostname: string, options: {
+    all: true;
+    verbatim: true;
+}) => Promise<DnsLookupResult[]>;
 declare function isBlockedHostname(hostname: string): boolean;
 declare function assertSafeOutboundUrl(rawUrl: string, options?: {
     allowHttp?: boolean;
 }): URL;
-export { assertSafeOutboundUrl, isBlockedHostname };
+declare function isBlockedIpAddress(address: string): boolean;
+declare function assertSafeOutboundUrlResolved(rawUrl: string, options?: {
+    allowHttp?: boolean;
+    resolveDns?: boolean;
+}): Promise<URL>;
+declare function setDnsLookupForTests(lookupFn: DnsLookup): void;
+declare function resetDnsLookupForTests(): void;
+export { assertSafeOutboundUrl, assertSafeOutboundUrlResolved, isBlockedHostname, isBlockedIpAddress, resetDnsLookupForTests, setDnsLookupForTests, };

package/dist/core/tenant/tenantDatabaseScope.d.ts

@@ -4,4 +4,5 @@ type TransactionHandle = {
 };
 declare function applyTenantContextToTransaction(transaction: TransactionHandle, tenantId: number): Promise<void>;
 declare function runWithTenantDatabase<T>(tenant: TenantContext, callback: () => T | Promise<T>): Promise<T>;
-export { applyTenantContextToTransaction, runWithTenantDatabase };
+declare function isInsideTenantDatabaseScope(tenantId?: number | undefined): boolean;
+export { applyTenantContextToTransaction, isInsideTenantDatabaseScope, runWithTenantDatabase };

package/dist/db/connection/index.d.ts

@@ -1,4 +1,4 @@
-import { type DatabaseConnection } from "./createConnection";
+import type { DatabaseConnection } from "./createConnection";
 declare function getDatabase(): DatabaseConnection;
 declare function pingDatabase(connection?: DatabaseConnection): Promise<boolean>;
 declare function ensureDatabaseConnection(): Promise<DatabaseConnection>;

package/dist/entries/auth/accessControl.js

@@ -1,113 +1 @@
-// @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
-};
+export * from "../../index.js";

package/dist/entries/auth/authContext.js

@@ -1,15 +1 @@
-// @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
-};
+export * from "../../index.js";