@getstrata/bootstrap 0.2.3 → 0.2.4

package/dist/bootstrap/app.d.ts

@@ -0,0 +1,7 @@
+declare class App {
+    private server?;
+    serve(): void;
+    stop(force?: boolean): void;
+    private resolvePort;
+}
+export default App;

package/dist/bootstrap/createRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { AppDependencies, AppRouteMap } from "./contracts";
+declare function createRoutes(dependencies: AppDependencies): AppRouteMap;
+export { createRoutes };

package/dist/bootstrap/createSpaRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { AppDependencies, AppRouteMap } from "./contracts";
+declare const SPA_DIST_DIRECTORY: string;
+declare function createSpaRoutes(_dependencies: AppDependencies): AppRouteMap;
+declare function mergeSpaRoutes(dependencies: AppDependencies, routes: AppRouteMap): AppRouteMap;
+export { createSpaRoutes, mergeSpaRoutes, SPA_DIST_DIRECTORY };

package/dist/bootstrap/dependencies.d.ts

@@ -0,0 +1,4 @@
+import { createAppContext } from "./context";
+declare function createAppDependencies(): import("./contracts").AppDependencies;
+export type { AppContext, AppDependencies } from "./contracts";
+export { createAppContext, createAppDependencies };

package/dist/bootstrap/health.d.ts

@@ -0,0 +1,8 @@
+import type { AppDependencies } from "./contracts";
+declare function checkDatabase(): Promise<boolean>;
+declare function checkRedis(redisUrl: string): Promise<boolean>;
+declare function createHealthRoutes(dependencies: AppDependencies): {
+    "/health": () => Promise<Response>;
+    "/ready": () => Promise<Response>;
+};
+export { checkDatabase, checkRedis, createHealthRoutes };

package/dist/bootstrap/metricsRoutes.d.ts

@@ -0,0 +1,4 @@
+declare function createMetricsRoutes(): {
+    "/metrics": () => Promise<Response>;
+};
+export { createMetricsRoutes };

package/dist/bootstrap/middleware.d.ts

@@ -0,0 +1,4 @@
+import { type Middleware } from "../core/http/middleware";
+import type { AppDependencies } from "./contracts";
+declare function createDefaultMiddleware(dependencies: AppDependencies): Middleware[];
+export { createDefaultMiddleware };

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

@@ -13,4 +13,4 @@ export { createWebRoutes, mergeWebRoutes } from "./createWebRoutes.ts";
 export { createHttpKernel, type HttpKernel, type MiddlewareGroupName } from "./httpKernel.ts";
 export { prefixRouteMap } from "./prefixRouteMap.ts";
 export { coreProviders } from "./providers/index.ts";
-export { CookieSessionStore, createCsrfProtection, createWebServer, type ParsedForm, parseFormBody, type SessionUser, slugify, type WebServerOptions, } from "./web/index.ts";
+export { CookieSessionStore, createCsrfProtection, createRouteKernel, createWebServer, type ParsedForm, parseFormBody, routeParams, type SessionUser, slugify, toRouteRequest, type WebServerOptions, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./web/index.ts";

package/dist/bootstrap/routes.d.ts

@@ -0,0 +1,2 @@
+declare const routes: import("./contracts").AppRouteMap;
+export { routes };

package/dist/bootstrap/scimRoutes.d.ts

@@ -0,0 +1,24 @@
+import type { RouteHandler } from "../core/http/middleware";
+import type { AppDependencies } from "./contracts";
+declare function createScimRoutes(dependencies: AppDependencies): {
+    "/scim/v2/ServiceProviderConfig": {
+        GET: RouteHandler;
+    };
+    "/scim/v2/Users": {
+        GET: RouteHandler;
+        POST: RouteHandler;
+    };
+    "/scim/v2/Users/:id": {
+        GET: RouteHandler;
+        PATCH: RouteHandler;
+        DELETE: RouteHandler;
+    };
+    "/scim/v2/Groups": {
+        GET: RouteHandler;
+    };
+    "/scim/v2/Groups/:id": {
+        GET: RouteHandler;
+        PATCH: RouteHandler;
+    };
+};
+export { createScimRoutes };

package/dist/bootstrap/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bootstrap/web/index.d.ts

@@ -2,6 +2,7 @@
  * Web-focused bootstrap utilities for sibling apps (getstrata, marketing sites).
  */
 export { createCsrfProtection, type ParsedForm, parseFormBody } from "./forms.ts";
+export { createRouteKernel, routeParams, toRouteRequest, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./routing.ts";
 export { convertAppRoutesToBunRoutes, createWebServer, type WebServerOptions } from "./server.ts";
 export { CookieSessionStore, type SessionUser } from "./session.ts";
 export { slugify } from "./slug.ts";

package/dist/bootstrap/web/routing.d.ts

@@ -0,0 +1,21 @@
+import type { RouteHandler, RouteRequest } from "@getstrata/core";
+import type { AppDependencies } from "../contracts.ts";
+import type { HttpKernel } from "../httpKernel.ts";
+/** Read Bun native `:param` values from a route handler request. */
+export declare function routeParams(request: Request): Record<string, string>;
+/**
+ * Attach decoded route params to Bun's native Request for RouteRequest handlers.
+ * Mutates the request in place so instanceof Request and Bun internals stay valid.
+ */
+export declare function toRouteRequest<TParams extends Record<string, string>>(request: Request): RouteRequest<TParams>;
+/** Laravel-style secured route-model binding for string keys (slugs, UUIDs). */
+export declare function wrapSecuredRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: {
+    resource: string;
+    action: "view" | "create" | "update" | "delete";
+}, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): RouteHandler;
+/** Converts kernel login throttle 429 JSON into an HTML response for web forms. */
+export declare function wrapWebLogin(kernel: HttpKernel, handler: RouteHandler, onThrottled: (request: Request) => Response | Promise<Response>): RouteHandler;
+/** Converts kernel register throttle 429 JSON into an HTML response for web forms. */
+export declare function wrapWebRegister(kernel: HttpKernel, handler: RouteHandler, onThrottled: (request: Request) => Response | Promise<Response>): RouteHandler;
+/** Convenience alias: HttpKernel is the Laravel-style router middleware wrapper. */
+export declare function createRouteKernel(dependencies: AppDependencies): HttpKernel;

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

@@ -0,0 +1,3 @@
+import type { Middleware } from "../http/middleware";
+declare function createScimAuthMiddleware(): Middleware;
+export { createScimAuthMiddleware };

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

@@ -0,0 +1,9 @@
+import type { Middleware } from "./middleware";
+interface ScimThrottleOptions {
+    redisUrl?: string;
+    maxAttempts: number;
+    decaySeconds: number;
+}
+declare function createScimThrottleMiddleware(options: ScimThrottleOptions): Middleware;
+export type { ScimThrottleOptions };
+export { createScimThrottleMiddleware };

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

@@ -0,0 +1,3 @@
+declare function parseScimTenantTokens(raw: string | undefined): Map<number, string>;
+declare function resolveScimTenantFromToken(token: string): number | null;
+export { parseScimTenantTokens, resolveScimTenantFromToken };

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

@@ -0,0 +1,2 @@
+declare function timingSafeCompareString(left: string, right: string): boolean;
+export { timingSafeCompareString };

package/dist/index.js

@@ -5333,6 +5333,51 @@ async function parseFormBody(request) {
   }
   return { fields, files };
 }
+// ../../src/bootstrap/web/routing.ts
+import { securedBindRouteModelByKey, withErrorHandling } from "@getstrata/core";
+function routeParams(request) {
+  const normalized = {};
+  const raw = request.params;
+  if (raw && typeof raw === "object") {
+    for (const [key, value] of Object.entries(raw)) {
+      normalized[key] = decodeURIComponent(String(value));
+    }
+  }
+  return normalized;
+}
+function toRouteRequest(request) {
+  const params = routeParams(request);
+  Object.defineProperty(request, "params", {
+    value: params,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  return request;
+}
+function wrapSecuredRouteModelByKey(param, resolver, authorization, handler) {
+  const bound = withErrorHandling(securedBindRouteModelByKey(param, resolver, authorization, handler));
+  return async (request) => bound(toRouteRequest(request));
+}
+function wrapWebLogin(kernel, handler, onThrottled) {
+  return wrapWebThrottle(kernel, "login", handler, onThrottled);
+}
+function wrapWebRegister(kernel, handler, onThrottled) {
+  return wrapWebThrottle(kernel, "register", handler, onThrottled);
+}
+function wrapWebThrottle(kernel, scope, handler, onThrottled) {
+  const throttled = scope === "login" ? kernel.wrapLogin(handler) : kernel.wrapRegister(handler);
+  return async (request) => {
+    const response = await throttled(request);
+    if (response.status === 429) {
+      return onThrottled(request);
+    }
+    return response;
+  };
+}
+function createRouteKernel(dependencies) {
+  return createHttpKernel(dependencies);
+}
 // ../../src/bootstrap/web/server.ts
 function wrapRouteHandler2(handler) {
   return async (request) => {
@@ -5456,11 +5501,16 @@ function slugify(value) {
   return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
 export {
+  wrapWebRegister,
+  wrapWebLogin,
+  wrapSecuredRouteModelByKey,
+  toRouteRequest,
   slugify,
   setActiveApplicationContext2 as setActiveApplicationContext,
   scheduleRunCommand,
   runProviderPhase,
   runDueScheduledTasks,
+  routeParams,
   resolveService,
   resolveApplicationQueue2 as resolveApplicationQueue,
   prefixRouteMap,
@@ -5469,6 +5519,7 @@ export {
   getRequiredDependency,
   createWebServer,
   createWebRoutes,
+  createRouteKernel,
   createHttpKernel,
   createCsrfProtection,
   createAppContext,

package/dist/modules/scim/controller.d.ts

@@ -0,0 +1,15 @@
+import type { AppDependencies } from "@getstrata/bootstrap/contracts";
+declare class ScimController {
+    private readonly service;
+    constructor(dependencies: AppDependencies);
+    readonly serviceProviderConfig: () => Promise<Response>;
+    readonly listUsers: (request: Request) => Promise<Response>;
+    readonly createUser: (request: Request) => Promise<Response>;
+    readonly showUser: (request: Request) => Promise<Response>;
+    readonly patchUser: (request: Request) => Promise<Response>;
+    readonly deleteUser: (request: Request) => Promise<Response>;
+    readonly listGroups: (request: Request) => Promise<Response>;
+    readonly showGroup: (request: Request) => Promise<Response>;
+    readonly patchGroup: (request: Request) => Promise<Response>;
+}
+export default ScimController;

package/dist/modules/scim/scimResponse.d.ts

@@ -0,0 +1,10 @@
+import { type EtagVersioned } from "@getstrata/core/http/etag";
+interface ScimResponseOptions {
+    status?: number;
+    request?: Request;
+    etagSource?: EtagVersioned;
+}
+declare function scimResponse(data: unknown, options?: ScimResponseOptions): Response;
+declare function assertScimIfMatch(request: Request, etagSource: EtagVersioned): void;
+export type { ScimResponseOptions };
+export { assertScimIfMatch, scimResponse };

package/dist/modules/scim/service.d.ts

@@ -0,0 +1,217 @@
+import type { AppDependencies } from "@getstrata/bootstrap/contracts";
+import OrganizationMemberRepository from "../organization/memberRepository";
+import type UserRepository from "../user/repository";
+interface ScimUserPayload {
+    userName?: string;
+    name?: {
+        formatted?: string;
+    };
+    active?: boolean;
+    emails?: Array<{
+        value: string;
+        primary?: boolean;
+    }>;
+}
+interface ScimPatchOperation {
+    op: string;
+    path?: string;
+    value?: unknown;
+}
+declare class ScimService {
+    private readonly users;
+    private readonly members;
+    constructor(users: UserRepository, members: OrganizationMemberRepository);
+    serviceProviderConfig(): {
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"[];
+        patch: {
+            supported: boolean;
+        };
+        bulk: {
+            supported: boolean;
+        };
+        filter: {
+            supported: boolean;
+        };
+        changePassword: {
+            supported: boolean;
+        };
+        sort: {
+            supported: boolean;
+        };
+        etag: {
+            supported: boolean;
+        };
+        authenticationSchemes: {
+            type: string;
+            name: string;
+            description: string;
+        }[];
+    };
+    listUsers(startIndex?: number, count?: number): Promise<{
+        schemas: "urn:ietf:params:scim:api:messages:2.0:ListResponse"[];
+        totalResults: number;
+        startIndex: number;
+        itemsPerPage: number;
+        Resources: {
+            schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+            id: string;
+            userName: string;
+            name: {
+                formatted: string;
+            };
+            displayName: string;
+            active: boolean;
+            emails: {
+                value: string;
+                primary: boolean;
+                type: string;
+            }[];
+            roles: {
+                value: string;
+                primary: boolean;
+            }[];
+            meta: {
+                resourceType: string;
+                created: string | undefined;
+                lastModified: string | undefined;
+            };
+        }[];
+    }>;
+    getUser(id: number): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    findUserRecord(id: number): Promise<import("../user/types").UserRecord>;
+    createUser(payload: ScimUserPayload): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    patchUser(id: number, operations: ScimPatchOperation[]): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    deleteUser(id: number): Promise<{
+        id: number;
+        updated_at: Date;
+    }>;
+    listGroups(startIndex?: number, count?: number): Promise<{
+        schemas: "urn:ietf:params:scim:api:messages:2.0:ListResponse"[];
+        totalResults: number;
+        startIndex: number;
+        itemsPerPage: number;
+        Resources: {
+            schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+            id: string;
+            displayName: string;
+            externalId: string;
+            members: {
+                value: string;
+                display: string;
+            }[];
+            meta: {
+                resourceType: string;
+                lastModified: string;
+            };
+        }[];
+    }>;
+    getGroup(id: number): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+        id: string;
+        displayName: string;
+        externalId: string;
+        members: {
+            value: string;
+            display: string;
+        }[];
+        meta: {
+            resourceType: string;
+            lastModified: string;
+        };
+    }>;
+    findOrganizationRecord(id: number): Promise<{
+        id: number;
+        name: string;
+        slug: string;
+        updated_at: Date;
+    }>;
+    patchGroup(id: number, operations: ScimPatchOperation[]): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+        id: string;
+        displayName: string;
+        externalId: string;
+        members: {
+            value: string;
+            display: string;
+        }[];
+        meta: {
+            resourceType: string;
+            lastModified: string;
+        };
+    }>;
+    private toScimGroup;
+    private toScimUser;
+}
+declare function createScimService(dependencies: AppDependencies): ScimService;
+export default ScimService;
+export type { ScimPatchOperation, ScimUserPayload };
+export { createScimService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/bootstrap",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Strata application bootstrap — HttpKernel, DI, web session helpers",
   "type": "module",
   "license": "MIT",
@@ -16,42 +16,42 @@
       "default": "./dist/index.js"
     },
     "./applicationRegistry": {
-      "types": "./dist/entries/applicationRegistry.d.ts",
+      "types": "./dist/bootstrap/applicationRegistry.d.ts",
       "import": "./dist/entries/applicationRegistry.js",
       "default": "./dist/entries/applicationRegistry.js"
     },
     "./config": {
-      "types": "./dist/entries/config.d.ts",
+      "types": "./dist/bootstrap/config.d.ts",
       "import": "./dist/entries/config.js",
       "default": "./dist/entries/config.js"
     },
     "./context": {
-      "types": "./dist/entries/context.d.ts",
+      "types": "./dist/bootstrap/context.d.ts",
       "import": "./dist/entries/context.js",
       "default": "./dist/entries/context.js"
     },
     "./contracts": {
-      "types": "./dist/entries/contracts.d.ts",
+      "types": "./dist/bootstrap/contracts.d.ts",
       "import": "./dist/entries/contracts.js",
       "default": "./dist/entries/contracts.js"
     },
     "./createWebRoutes": {
-      "types": "./dist/entries/createWebRoutes.d.ts",
+      "types": "./dist/bootstrap/createWebRoutes.d.ts",
       "import": "./dist/entries/createWebRoutes.js",
       "default": "./dist/entries/createWebRoutes.js"
     },
     "./httpKernel": {
-      "types": "./dist/entries/httpKernel.d.ts",
+      "types": "./dist/bootstrap/httpKernel.d.ts",
       "import": "./dist/entries/httpKernel.js",
       "default": "./dist/entries/httpKernel.js"
     },
     "./providers": {
-      "types": "./dist/entries/providers.d.ts",
+      "types": "./dist/bootstrap/providers/index.d.ts",
       "import": "./dist/entries/providers.js",
       "default": "./dist/entries/providers.js"
     },
     "./providers/view": {
-      "types": "./dist/entries/providers/view.d.ts",
+      "types": "./dist/bootstrap/providers/view/index.d.ts",
       "import": "./dist/entries/providers/view.js",
       "default": "./dist/entries/providers/view.js"
     }
@@ -73,7 +73,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@getstrata/core": "^0.5.6",
+    "@getstrata/core": "^0.5.9",
     "typescript": "^5.9.0"
   }
 }