@shivaedev/admin 0.21.0 → 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,20 @@
1
1
  # Changelog
2
2
 
3
+ ## 0.22.0 - 2026-11-06
4
+
5
+ ### Breaking
6
+
7
+ - Generated page subscriptions return their initial authorized query value. Raw subscription consumers handle `Result` instead of waiting for an initial `Resync`.
8
+
9
+ ## 0.21.1 - 2026-11-05
10
+
11
+ ### Changed
12
+
13
+ - Update `@shivaedev/contract` from 0.39.0 to 0.40.0.
14
+ - Update `@shivaedev/identity` from 0.27.0 to 0.28.0.
15
+ - Update `@shivaedev/jobs` from 0.39.0 to 0.40.0.
16
+ - Update `@shivaedev/react` from 0.44.0 to 0.44.1.
17
+
3
18
  ## 0.21.0 - 2026-11-05
4
19
 
5
20
  ### Breaking
package/README.md CHANGED
@@ -22,6 +22,8 @@ The page exposes `admin.jobs.failed` and the generated `admin.jobs.$changes` sub
22
22
 
23
23
  ### How to think about it
24
24
 
25
+ With the application host, a generated query subscription returns its first authorized result after registering read keys. Bound admin screens consume that value in one RPC request. Raw subscription readers handle `Result` values alongside later change hints.
26
+
25
27
  An admin page is a native `@shivaedev/contract` contract plus a stable id, route metadata and one permission middleware. The page applies that middleware to every operation in its contract, so no admin operation exists without a permission check. The registry merges the pages into one native RPC group, and server registration pairs each page id with the handler Layer the application writes. Admin supplies optional default React views for Users, Sessions and Jobs. The application owns the admin shell, custom views, route composition, styling, session policy and RPC host.
26
28
 
27
29
  ### Declare pages and the registry
@@ -270,4 +272,4 @@ Install `@shivaedev/admin` with its required `effect` peer. Registry, contract a
270
272
 
271
273
  Page declarations and the registry are browser-safe and add no transport. Server registration lives under `/server`, and the optional default Jobs, Users and Sessions views under `/client/adapters` use React. Applications own route composition and styling.
272
274
 
273
- This package declares the permission middleware and does not resolve sessions. `permissionLayer` from `@shivaedev/identity/server/permissions.ts` resolves each request's session through the session policy the application supplies, then checks the page's permission.
275
+ This package declares the permission middleware and does not resolve sessions. `permissionLayer` from `@shivaedev/identity/server/permissionLayer.ts` resolves each request's session through the session policy the application supplies, then checks the page's permission.
@@ -195,7 +195,108 @@ export declare function jobsPage<const TQueues extends readonly JobsEntry[]>(...
195
195
  readonly queryIndexes: Schema.optional<Schema.$Array<Schema.Number>>;
196
196
  }>, Schema.Struct<{
197
197
  readonly _tag: Schema.Literal<"Resync">;
198
- }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...never[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("#jobs/schemas.ts").JobsUnavailable | typeof import("#jobs/schemas.ts").JobsPayloadInvalid | typeof import("#jobs/schemas.ts").JobsQueueUnregistered)[]>[]]>>, Schema.Never, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
198
+ }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...(Schema.Struct<{
199
+ _tag: Schema.Literal<"Result">;
200
+ query: Schema.Literal<"counts">;
201
+ queryIndex: Schema.Number;
202
+ value: Schema.Struct<{
203
+ readonly activeCount: Schema.Number;
204
+ readonly failedCount: Schema.Number;
205
+ readonly queuedCount: Schema.Number;
206
+ readonly totalCount: Schema.Number;
207
+ }>;
208
+ }> | Schema.Struct<{
209
+ _tag: Schema.Literal<"Result">;
210
+ query: Schema.Literal<"deadLettered">;
211
+ queryIndex: Schema.Number;
212
+ value: Schema.Struct<{
213
+ readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
214
+ readonly attempt: Schema.Number;
215
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
216
+ readonly createdOn: Schema.DateTimeUtcFromString;
217
+ readonly id: Schema.String;
218
+ readonly output: Schema.NullOr<Schema.Struct<{
219
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
220
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
221
+ }>>;
222
+ readonly retryCount: Schema.Number;
223
+ readonly retryLimit: Schema.Number;
224
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
225
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
226
+ readonly data: Schema.Unknown;
227
+ readonly queue: Schema.Literal<string>;
228
+ readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
229
+ readonly sourceOutput: Schema.NullOr<Schema.Struct<{
230
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
231
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
232
+ }>>;
233
+ readonly sourceQueue: Schema.Literal<string>;
234
+ }>[]>>;
235
+ readonly next: Schema.OptionFromNullOr<Schema.String>;
236
+ }>;
237
+ }> | Schema.Struct<{
238
+ _tag: Schema.Literal<"Result">;
239
+ query: Schema.Literal<"failed">;
240
+ queryIndex: Schema.Number;
241
+ value: Schema.Struct<{
242
+ readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
243
+ readonly attempt: Schema.Number;
244
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
245
+ readonly createdOn: Schema.DateTimeUtcFromString;
246
+ readonly id: Schema.String;
247
+ readonly output: Schema.NullOr<Schema.Struct<{
248
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
249
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
250
+ }>>;
251
+ readonly retryCount: Schema.Number;
252
+ readonly retryLimit: Schema.Number;
253
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
254
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
255
+ readonly data: Schema.Unknown;
256
+ readonly queue: Schema.Literal<string>;
257
+ }>[]>>;
258
+ readonly next: Schema.OptionFromNullOr<Schema.String>;
259
+ }>;
260
+ }> | Schema.Struct<{
261
+ _tag: Schema.Literal<"Result">;
262
+ query: Schema.Literal<"health">;
263
+ queryIndex: Schema.Number;
264
+ value: Schema.Struct<{
265
+ readonly activeTotal: Schema.Number;
266
+ readonly deadLetteredTotal: Schema.Number;
267
+ readonly failedTotal: Schema.Number;
268
+ readonly jobs: Schema.$Array<Schema.Struct<{
269
+ readonly activeCount: Schema.Number;
270
+ readonly deadLetteredCount: Schema.Number;
271
+ readonly failedCount: Schema.Number;
272
+ readonly name: Schema.String;
273
+ readonly queuedCount: Schema.Number;
274
+ readonly readyCount: Schema.Number;
275
+ }>>;
276
+ readonly queuedTotal: Schema.Number;
277
+ readonly readyTotal: Schema.Number;
278
+ }>;
279
+ }> | Schema.Struct<{
280
+ _tag: Schema.Literal<"Result">;
281
+ query: Schema.Literal<"job">;
282
+ queryIndex: Schema.Number;
283
+ value: Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
284
+ readonly attempt: Schema.Number;
285
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
286
+ readonly createdOn: Schema.DateTimeUtcFromString;
287
+ readonly id: Schema.String;
288
+ readonly output: Schema.NullOr<Schema.Struct<{
289
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
290
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
291
+ }>>;
292
+ readonly retryCount: Schema.Number;
293
+ readonly retryLimit: Schema.Number;
294
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
295
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
296
+ readonly data: Schema.Unknown;
297
+ readonly queue: Schema.Literal<string>;
298
+ }>[]>>;
299
+ }>)[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("#jobs/schemas.ts").JobsUnavailable | typeof import("#jobs/schemas.ts").JobsPayloadInvalid | typeof import("#jobs/schemas.ts").JobsQueueUnregistered)[]>[]]>>, Schema.Never, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
199
300
  readonly rpc: import("effect/rpc/Rpc").Any;
200
301
  readonly payload: unknown;
201
302
  }) => Effect.Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
@@ -1 +1 @@
1
- {"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../src/jobs/page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,gBAAgB,CAAC;AAI7E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,wBAAgB,QAAQ,CAAC,KAAK,CAAC,OAAO,SAAS,SAAS,SAAS,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDtF"}
1
+ {"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../src/jobs/page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,gBAAgB,CAAC;AAI7E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,wBAAgB,QAAQ,CAAC,KAAK,CAAC,OAAO,SAAS,SAAS,SAAS,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDtF"}
@@ -187,7 +187,33 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
187
187
  readonly JobsUnavailable: typeof import("./schemas.ts").JobsUnavailable;
188
188
  readonly Forbidden: typeof Forbidden;
189
189
  readonly JobsNotFailed: typeof JobsNotFailed;
190
- }>>], import("effect/rpc/Rpc").Rpc<"admin.jobs.$changes", Schema.Struct<{
190
+ }>>], import("effect/rpc/Rpc").Rpc<"admin.jobs.job", Schema.Struct<{
191
+ id: Schema.String;
192
+ queue: Schema.String;
193
+ }>, Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
194
+ readonly attempt: Schema.Number;
195
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
196
+ readonly createdOn: Schema.DateTimeUtcFromString;
197
+ readonly id: Schema.String;
198
+ readonly output: Schema.NullOr<Schema.Struct<{
199
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
200
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
201
+ }>>;
202
+ readonly retryCount: Schema.Number;
203
+ readonly retryLimit: Schema.Number;
204
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
205
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
206
+ readonly data: Schema.Unknown;
207
+ readonly queue: Schema.Literal<string>;
208
+ }>[]>>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
209
+ readonly rpc: import("effect/rpc/Rpc").Any;
210
+ readonly payload: unknown;
211
+ }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
212
+ "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
213
+ "~ClientError": never;
214
+ error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
215
+ requiredForClient: false;
216
+ }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.$changes", Schema.Struct<{
191
217
  queries: Schema.$Array<Schema.Union<readonly (Schema.Struct<{
192
218
  query: Schema.Literal<"counts">;
193
219
  payload: Schema.Struct<{
@@ -235,7 +261,108 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
235
261
  readonly queryIndexes: Schema.optional<Schema.$Array<Schema.Number>>;
236
262
  }>, Schema.Struct<{
237
263
  readonly _tag: Schema.Literal<"Resync">;
238
- }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...never[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>[]]>>, Schema.Never, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
264
+ }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...(Schema.Struct<{
265
+ _tag: Schema.Literal<"Result">;
266
+ query: Schema.Literal<"counts">;
267
+ queryIndex: Schema.Number;
268
+ value: Schema.Struct<{
269
+ readonly activeCount: Schema.Number;
270
+ readonly failedCount: Schema.Number;
271
+ readonly queuedCount: Schema.Number;
272
+ readonly totalCount: Schema.Number;
273
+ }>;
274
+ }> | Schema.Struct<{
275
+ _tag: Schema.Literal<"Result">;
276
+ query: Schema.Literal<"deadLettered">;
277
+ queryIndex: Schema.Number;
278
+ value: Schema.Struct<{
279
+ readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
280
+ readonly attempt: Schema.Number;
281
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
282
+ readonly createdOn: Schema.DateTimeUtcFromString;
283
+ readonly id: Schema.String;
284
+ readonly output: Schema.NullOr<Schema.Struct<{
285
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
286
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
287
+ }>>;
288
+ readonly retryCount: Schema.Number;
289
+ readonly retryLimit: Schema.Number;
290
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
291
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
292
+ readonly data: Schema.Unknown;
293
+ readonly queue: Schema.Literal<string>;
294
+ readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
295
+ readonly sourceOutput: Schema.NullOr<Schema.Struct<{
296
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
297
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
298
+ }>>;
299
+ readonly sourceQueue: Schema.Literal<string>;
300
+ }>[]>>;
301
+ readonly next: Schema.OptionFromNullOr<Schema.String>;
302
+ }>;
303
+ }> | Schema.Struct<{
304
+ _tag: Schema.Literal<"Result">;
305
+ query: Schema.Literal<"failed">;
306
+ queryIndex: Schema.Number;
307
+ value: Schema.Struct<{
308
+ readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
309
+ readonly attempt: Schema.Number;
310
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
311
+ readonly createdOn: Schema.DateTimeUtcFromString;
312
+ readonly id: Schema.String;
313
+ readonly output: Schema.NullOr<Schema.Struct<{
314
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
315
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
316
+ }>>;
317
+ readonly retryCount: Schema.Number;
318
+ readonly retryLimit: Schema.Number;
319
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
320
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
321
+ readonly data: Schema.Unknown;
322
+ readonly queue: Schema.Literal<string>;
323
+ }>[]>>;
324
+ readonly next: Schema.OptionFromNullOr<Schema.String>;
325
+ }>;
326
+ }> | Schema.Struct<{
327
+ _tag: Schema.Literal<"Result">;
328
+ query: Schema.Literal<"health">;
329
+ queryIndex: Schema.Number;
330
+ value: Schema.Struct<{
331
+ readonly activeTotal: Schema.Number;
332
+ readonly deadLetteredTotal: Schema.Number;
333
+ readonly failedTotal: Schema.Number;
334
+ readonly jobs: Schema.$Array<Schema.Struct<{
335
+ readonly activeCount: Schema.Number;
336
+ readonly deadLetteredCount: Schema.Number;
337
+ readonly failedCount: Schema.Number;
338
+ readonly name: Schema.String;
339
+ readonly queuedCount: Schema.Number;
340
+ readonly readyCount: Schema.Number;
341
+ }>>;
342
+ readonly queuedTotal: Schema.Number;
343
+ readonly readyTotal: Schema.Number;
344
+ }>;
345
+ }> | Schema.Struct<{
346
+ _tag: Schema.Literal<"Result">;
347
+ query: Schema.Literal<"job">;
348
+ queryIndex: Schema.Number;
349
+ value: Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
350
+ readonly attempt: Schema.Number;
351
+ readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
352
+ readonly createdOn: Schema.DateTimeUtcFromString;
353
+ readonly id: Schema.String;
354
+ readonly output: Schema.NullOr<Schema.Struct<{
355
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
356
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
357
+ }>>;
358
+ readonly retryCount: Schema.Number;
359
+ readonly retryLimit: Schema.Number;
360
+ readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
361
+ readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
362
+ readonly data: Schema.Unknown;
363
+ readonly queue: Schema.Literal<string>;
364
+ }>[]>>;
365
+ }>)[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>[]]>>, Schema.Never, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
239
366
  readonly rpc: import("effect/rpc/Rpc").Any;
240
367
  readonly payload: unknown;
241
368
  }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
@@ -258,7 +385,29 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
258
385
  "~ClientError": never;
259
386
  error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
260
387
  requiredForClient: false;
261
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.deadLettered", Schema.Struct<{
388
+ }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.health", Schema.Void, Schema.Struct<{
389
+ readonly activeTotal: Schema.Number;
390
+ readonly deadLetteredTotal: Schema.Number;
391
+ readonly failedTotal: Schema.Number;
392
+ readonly jobs: Schema.$Array<Schema.Struct<{
393
+ readonly activeCount: Schema.Number;
394
+ readonly deadLetteredCount: Schema.Number;
395
+ readonly failedCount: Schema.Number;
396
+ readonly name: Schema.String;
397
+ readonly queuedCount: Schema.Number;
398
+ readonly readyCount: Schema.Number;
399
+ }>>;
400
+ readonly queuedTotal: Schema.Number;
401
+ readonly readyTotal: Schema.Number;
402
+ }>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
403
+ readonly rpc: import("effect/rpc/Rpc").Any;
404
+ readonly payload: unknown;
405
+ }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
406
+ "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
407
+ "~ClientError": never;
408
+ error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
409
+ requiredForClient: false;
410
+ }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.failed", Schema.Struct<{
262
411
  cursor: Schema.optionalKey<Schema.String>;
263
412
  limit: Schema.Number;
264
413
  queue: Schema.String;
@@ -278,12 +427,6 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
278
427
  readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
279
428
  readonly data: Schema.Unknown;
280
429
  readonly queue: Schema.Literal<string>;
281
- readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
282
- readonly sourceOutput: Schema.NullOr<Schema.Struct<{
283
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
284
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
285
- }>>;
286
- readonly sourceQueue: Schema.Literal<string>;
287
430
  }>[]>>;
288
431
  readonly next: Schema.OptionFromNullOr<Schema.String>;
289
432
  }>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
@@ -294,7 +437,7 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
294
437
  "~ClientError": never;
295
438
  error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
296
439
  requiredForClient: false;
297
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.failed", Schema.Struct<{
440
+ }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.deadLettered", Schema.Struct<{
298
441
  cursor: Schema.optionalKey<Schema.String>;
299
442
  limit: Schema.Number;
300
443
  queue: Schema.String;
@@ -314,6 +457,12 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
314
457
  readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
315
458
  readonly data: Schema.Unknown;
316
459
  readonly queue: Schema.Literal<string>;
460
+ readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
461
+ readonly sourceOutput: Schema.NullOr<Schema.Struct<{
462
+ readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
463
+ readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
464
+ }>>;
465
+ readonly sourceQueue: Schema.Literal<string>;
317
466
  }>[]>>;
318
467
  readonly next: Schema.OptionFromNullOr<Schema.String>;
319
468
  }>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
@@ -324,54 +473,6 @@ export declare function jobsPageWithRetry<const TQueues extends readonly JobsEnt
324
473
  "~ClientError": never;
325
474
  error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
326
475
  requiredForClient: false;
327
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.health", Schema.Void, Schema.Struct<{
328
- readonly activeTotal: Schema.Number;
329
- readonly deadLetteredTotal: Schema.Number;
330
- readonly failedTotal: Schema.Number;
331
- readonly jobs: Schema.$Array<Schema.Struct<{
332
- readonly activeCount: Schema.Number;
333
- readonly deadLetteredCount: Schema.Number;
334
- readonly failedCount: Schema.Number;
335
- readonly name: Schema.String;
336
- readonly queuedCount: Schema.Number;
337
- readonly readyCount: Schema.Number;
338
- }>>;
339
- readonly queuedTotal: Schema.Number;
340
- readonly readyTotal: Schema.Number;
341
- }>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
342
- readonly rpc: import("effect/rpc/Rpc").Any;
343
- readonly payload: unknown;
344
- }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
345
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
346
- "~ClientError": never;
347
- error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
348
- requiredForClient: false;
349
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.job", Schema.Struct<{
350
- id: Schema.String;
351
- queue: Schema.String;
352
- }>, Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
353
- readonly attempt: Schema.Number;
354
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
355
- readonly createdOn: Schema.DateTimeUtcFromString;
356
- readonly id: Schema.String;
357
- readonly output: Schema.NullOr<Schema.Struct<{
358
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
359
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
360
- }>>;
361
- readonly retryCount: Schema.Number;
362
- readonly retryLimit: Schema.Number;
363
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
364
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
365
- readonly data: Schema.Unknown;
366
- readonly queue: Schema.Literal<string>;
367
- }>[]>>, Schema.Union<readonly [Schema.Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").BadRequest | typeof import("./schemas.ts").JobsUnavailable | typeof import("./schemas.ts").JobsPayloadInvalid | typeof import("./schemas.ts").JobsQueueUnregistered)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
368
- readonly rpc: import("effect/rpc/Rpc").Any;
369
- readonly payload: unknown;
370
- }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
371
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
372
- "~ClientError": never;
373
- error: Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
374
- requiredForClient: false;
375
476
  }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.retry", Schema.Struct<{
376
477
  id: Schema.String;
377
478
  queue: Schema.String;
@@ -1 +1 @@
1
- {"version":3,"file":"retryPage.d.ts","sourceRoot":"","sources":["../../src/jobs/retryPage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;;;;;AAK5C,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;AAEL,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,OAAO,SAAS,SAAS,SAAS,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B/F"}
1
+ {"version":3,"file":"retryPage.d.ts","sourceRoot":"","sources":["../../src/jobs/retryPage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;;;;;AAK5C,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;AAEL,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,OAAO,SAAS,SAAS,SAAS,EAAE,EAAE,GAAG,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B/F"}
@@ -1,6 +1,5 @@
1
1
  import { Effect } from "effect";
2
- import type { HttpServerRequest } from "effect/http";
3
- import { HttpRouter, HttpServerResponse } from "effect/http";
2
+ import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
4
3
  import type { AnyAdminRegistry } from "#registry.ts";
5
4
  export declare function adminDocuments<E, R>(registry: AnyAdminRegistry, handler: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", import("@shivaedev/identity/server/SessionPolicy.ts").SessionPolicy> | Exclude<HttpRouter.Request.From<"Error", E>, import("effect/Scope").Scope> | Exclude<HttpRouter.Request.From<"Requires", Exclude<Exclude<R, import("@shivaedev/identity/identity.ts").Identity | import("@shivaedev/identity/identity.ts").SessionUser>, HttpRouter.Provided>>, import("effect/Scope").Scope>>;
6
5
  //# sourceMappingURL=adminDocuments.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"adminDocuments.d.ts","sourceRoot":"","sources":["../../src/server/adminDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAI7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAClC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,KAAK,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,CAAC,EAAE,CAAC,CAAC,2dAcrH"}
1
+ {"version":3,"file":"adminDocuments.d.ts","sourceRoot":"","sources":["../../src/server/adminDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAClC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,KAAK,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,CAAC,EAAE,CAAC,CAAC,2dAcrH"}
@@ -1,7 +1,7 @@
1
1
  import { Effect } from "effect";
2
- import { HttpRouter, HttpServerResponse } from "effect/http";
2
+ import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
3
3
  import * as HttpStatus from "effect/http/HttpStatus";
4
- import { permissionRoute } from "@shivaedev/identity/server/permissions.ts";
4
+ import { permissionRoute } from "@shivaedev/identity/server/adapters/permissionRoute.ts";
5
5
  import { matchAdminRoute } from "#adapters/matchAdminRoute.ts";
6
6
  export function adminDocuments(registry, handler) {
7
7
  const routes = registry.pages.map((page) => page.route);
@@ -11,7 +11,7 @@ export function adminDocuments(registry, handler) {
11
11
  const route = matchAdminRoute(routes, path);
12
12
  return route === undefined
13
13
  ? Effect.succeed(HttpServerResponse.empty({ status: HttpStatus.fromLiteral("NotFound") }))
14
- : permissionRoute(route.permission)(handler)(request);
14
+ : permissionRoute(route.permission)(Effect.flatMap(HttpServerRequest.HttpServerRequest, handler));
15
15
  });
16
16
  }));
17
17
  }
@@ -1 +1 @@
1
- {"version":3,"file":"adminDocuments.js","sourceRoot":"","sources":["../../src/server/adminDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,UAAU,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAG/D,MAAM,UAAU,cAAc,CAC7B,QAA0B,EAC1B,OAAqH;IAErH,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAChC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE;YAChD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,QAAQ,CAAC;YAC/D,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC5C,OAAO,KAAK,KAAK,SAAS;gBACzB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAC1F,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CACF,CAAC;AACH,CAAC"}
1
+ {"version":3,"file":"adminDocuments.js","sourceRoot":"","sources":["../../src/server/adminDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,UAAU,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,wDAAwD,CAAC;AACzF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAG/D,MAAM,UAAU,cAAc,CAC7B,QAA0B,EAC1B,OAAqH;IAErH,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAChC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE;YAChD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,QAAQ,CAAC;YAC/D,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC5C,OAAO,KAAK,KAAK,SAAS;gBACzB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAC1F,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC,CAAC;QACpG,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CACF,CAAC;AACH,CAAC"}
@@ -1,5 +1,5 @@
1
1
  import { Context, Layer } from "effect";
2
- import { permissionLayer } from "@shivaedev/identity/server/permissions.ts";
2
+ import { permissionLayer } from "@shivaedev/identity/server/permissionLayer.ts";
3
3
  export function pagePermissions(registry) {
4
4
  return Layer.mergeAll(Layer.empty, ...registry.pages.map((page) => {
5
5
  const middleware = Context.Service(page.permissionKey);
@@ -1 +1 @@
1
- {"version":3,"file":"pagePermissions.js","sourceRoot":"","sources":["../../src/server/pagePermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIxC,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAG5E,MAAM,UAAU,eAAe,CAAC,QAA0B;IACzD,OAAO,KAAK,CAAC,QAAQ,CACpB,KAAK,CAAC,KAAK,EACX,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAwF,IAAI,CAAC,aAAa,CAAC,CAAC;QAC9I,OAAO,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC,CAAC,CACF,CAAC;AACH,CAAC"}
1
+ {"version":3,"file":"pagePermissions.js","sourceRoot":"","sources":["../../src/server/pagePermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIxC,OAAO,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAC;AAGhF,MAAM,UAAU,eAAe,CAAC,QAA0B;IACzD,OAAO,KAAK,CAAC,QAAQ,CACpB,KAAK,CAAC,KAAK,EACX,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAwF,IAAI,CAAC,aAAa,CAAC,CAAC;QAC9I,OAAO,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC,CAAC,CACF,CAAC;AACH,CAAC"}
@@ -76,7 +76,28 @@ export declare const SessionsPage: import("#page.ts").AdminPage & {
76
76
  readonly queryIndexes: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Number>>;
77
77
  }>, import("effect/Schema").Struct<{
78
78
  readonly _tag: import("effect/Schema").Literal<"Resync">;
79
- }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...never[]]>, import("effect/Schema").Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...import("effect/Schema").Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").Forbidden | typeof import("@shivaedev/errors/taxonomy.ts").AuthUnavailable)[]>[]]>>, import("effect/Schema").Never, typeof SessionsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
79
+ }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...import("effect/Schema").Struct<{
80
+ _tag: import("effect/Schema").Literal<"Result">;
81
+ query: import("effect/Schema").Literal<"list">;
82
+ queryIndex: import("effect/Schema").Number;
83
+ value: import("effect/Schema").Struct<{
84
+ readonly next: import("effect/Schema").OptionFromNullOr<import("effect/Schema").Struct<{
85
+ readonly id: import("effect/Schema").String;
86
+ readonly lastActivityAt: import("effect/Schema").DateTimeUtcFromString;
87
+ }>>;
88
+ readonly sessions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
89
+ readonly expiresAt: import("effect/Schema").DateTimeUtcFromDate;
90
+ readonly id: import("effect/Schema").String;
91
+ readonly lastActivityAt: import("effect/Schema").DateTimeUtcFromDate;
92
+ readonly startedAt: import("effect/Schema").DateTimeUtcFromDate;
93
+ readonly user: import("effect/Schema").Struct<{
94
+ readonly email: import("effect/Schema").String;
95
+ readonly id: import("effect/Schema").String;
96
+ readonly name: import("effect/Schema").String;
97
+ }>;
98
+ }>>;
99
+ }>;
100
+ }>[]]>, import("effect/Schema").Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...import("effect/Schema").Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").Forbidden | typeof import("@shivaedev/errors/taxonomy.ts").AuthUnavailable)[]>[]]>>, import("effect/Schema").Never, typeof SessionsPermission | (import("effect/Context").Reference<<A, E, R>(effect: import("effect/Effect").Effect<A, E, R>, request: {
80
101
  readonly rpc: import("effect/rpc/Rpc").Any;
81
102
  readonly payload: unknown;
82
103
  }) => import("effect/Effect").Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
@@ -84,9 +105,7 @@ export declare const SessionsPage: import("#page.ts").AdminPage & {
84
105
  "~ClientError": never;
85
106
  error: import("effect/Schema").Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
86
107
  requiredForClient: false;
87
- }), never> | import("effect/rpc/Rpc").Rpc<"identity.sessions.revoke", import("effect/Schema").Struct<{
88
- id: import("effect/Schema").String;
89
- }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").NotFound | typeof import("@shivaedev/errors/taxonomy.ts").Forbidden | typeof import("@shivaedev/errors/taxonomy.ts").AuthUnavailable)[]>, typeof SessionsPermission, never> | import("effect/rpc/Rpc").Rpc<"identity.sessions.list", import("effect/Schema").Struct<{
108
+ }), never> | import("effect/rpc/Rpc").Rpc<"identity.sessions.list", import("effect/Schema").Struct<{
90
109
  readonly cursor: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
91
110
  readonly id: import("effect/Schema").String;
92
111
  readonly lastActivityAt: import("effect/Schema").DateTimeUtcFromString;
@@ -116,6 +135,8 @@ export declare const SessionsPage: import("#page.ts").AdminPage & {
116
135
  "~ClientError": never;
117
136
  error: import("effect/Schema").Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired]>;
118
137
  requiredForClient: false;
119
- }), never>, readonly [], undefined>;
138
+ }), never> | import("effect/rpc/Rpc").Rpc<"identity.sessions.revoke", import("effect/Schema").Struct<{
139
+ id: import("effect/Schema").String;
140
+ }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly (typeof import("@shivaedev/errors/taxonomy.ts").NotFound | typeof import("@shivaedev/errors/taxonomy.ts").Forbidden | typeof import("@shivaedev/errors/taxonomy.ts").AuthUnavailable)[]>, typeof SessionsPermission, never>, readonly [], undefined>;
120
141
  };
121
142
  //# sourceMappingURL=Page.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"Page.d.ts","sourceRoot":"","sources":["../../src/sessions/Page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAI/E,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
1
+ {"version":3,"file":"Page.d.ts","sourceRoot":"","sources":["../../src/sessions/Page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAI/E,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
@@ -78,7 +78,22 @@ export declare function usersPage<const TRole extends string>(access: Pick<Acces
78
78
  readonly queryIndexes: Schema.optional<Schema.$Array<Schema.Number>>;
79
79
  }>, Schema.Struct<{
80
80
  readonly _tag: Schema.Literal<"Resync">;
81
- }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...never[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof Forbidden | typeof AuthUnavailable)[]>[]]>>, Schema.Never, typeof UsersPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
81
+ }>]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...Schema.Struct<{
82
+ _tag: Schema.Literal<"Result">;
83
+ query: Schema.Literal<"list">;
84
+ queryIndex: Schema.Number;
85
+ value: Schema.Struct<{
86
+ readonly next: Schema.OptionFromNullOr<Schema.String>;
87
+ readonly users: Schema.$Array<Schema.Struct<{
88
+ readonly createdAt: Schema.DateTimeUtcFromDate;
89
+ readonly email: Schema.String;
90
+ readonly id: Schema.String;
91
+ readonly name: Schema.String;
92
+ readonly role: Schema.String;
93
+ }>>;
94
+ readonly canChangeRoles: Schema.Boolean;
95
+ }>;
96
+ }>[]]>, Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, typeof import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired, ...Schema.Union<readonly (typeof Forbidden | typeof AuthUnavailable)[]>[]]>>, Schema.Never, typeof UsersPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
82
97
  readonly rpc: import("effect/rpc/Rpc").Any;
83
98
  readonly payload: unknown;
84
99
  }) => Effect.Effect<A, E | import("@shivaedev/contract/readPolicyErrors.ts").MissingReadPolicy | import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied | import("@shivaedev/contract/WebSocketRequired.ts").WebSocketRequired | import("effect/Types").unhandled, R>> & {
@@ -1 +1 @@
1
- {"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../src/users/page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,eAAO,MAAM,SAAS;;;;;;;;;;EAAwE,CAAC;AAC/F,wBAAgB,SAAS,CAAC,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB9F"}
1
+ {"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../src/users/page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,eAAO,MAAM,SAAS;;;;;;;;;;EAAwE,CAAC;AAC/F,wBAAgB,SAAS,CAAC,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB9F"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@shivaedev/admin",
3
- "version": "0.21.0",
3
+ "version": "0.22.0",
4
4
  "description": "Explicit admin page contracts and a protected native Effect RPC registry",
5
5
  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/admin#readme",
6
6
  "bugs": {
@@ -44,21 +44,21 @@
44
44
  "dependencies": {
45
45
  "@shivaedev/access": "0.6.0",
46
46
  "@shivaedev/changes": "0.11.0",
47
- "@shivaedev/contract": "0.39.0",
47
+ "@shivaedev/contract": "0.41.0",
48
48
  "@shivaedev/errors": "0.10.0",
49
- "@shivaedev/identity": "0.27.0",
50
- "@shivaedev/jobs": "0.39.0"
49
+ "@shivaedev/identity": "0.29.0",
50
+ "@shivaedev/jobs": "0.40.1"
51
51
  },
52
52
  "devDependencies": {
53
53
  "@effect/atom-react": "4.1.0",
54
- "@shivaedev/quality": "0.65.0",
55
- "@shivaedev/rate-limit": "0.6.0",
56
- "@shivaedev/react": "0.44.0",
57
- "@shivaedev/server": "0.27.0",
58
- "@shivaedev/sql": "0.42.0",
59
- "@shivaedev/test-kits": "0.8.0",
60
- "@shivaedev/test-sql": "0.24.0",
61
- "@shivaedev/test-story": "0.42.0",
54
+ "@shivaedev/quality": "0.67.0",
55
+ "@shivaedev/rate-limit": "0.6.2",
56
+ "@shivaedev/react": "0.44.2",
57
+ "@shivaedev/server": "0.29.0",
58
+ "@shivaedev/sql": "0.44.0",
59
+ "@shivaedev/test-kits": "0.9.0",
60
+ "@shivaedev/test-sql": "0.24.2",
61
+ "@shivaedev/test-story": "0.43.0",
62
62
  "@types/node": "24.19.2",
63
63
  "@types/react": "19.3.0",
64
64
  "@types/react-dom": "19.3.0",
@@ -71,7 +71,7 @@
71
71
  },
72
72
  "peerDependencies": {
73
73
  "@effect/atom-react": "4.1.0",
74
- "@shivaedev/react": "0.44.0",
74
+ "@shivaedev/react": "0.44.2",
75
75
  "effect": "4.1.0",
76
76
  "react": "19.3.1"
77
77
  },
@@ -1,8 +1,7 @@
1
1
  import { Effect } from "effect";
2
- import type { HttpServerRequest } from "effect/http";
3
- import { HttpRouter, HttpServerResponse } from "effect/http";
2
+ import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
4
3
  import * as HttpStatus from "effect/http/HttpStatus";
5
- import { permissionRoute } from "@shivaedev/identity/server/permissions.ts";
4
+ import { permissionRoute } from "@shivaedev/identity/server/adapters/permissionRoute.ts";
6
5
  import { matchAdminRoute } from "#adapters/matchAdminRoute.ts";
7
6
  import type { AnyAdminRegistry } from "#registry.ts";
8
7
 
@@ -18,7 +17,7 @@ export function adminDocuments<E, R>(
18
17
  const route = matchAdminRoute(routes, path);
19
18
  return route === undefined
20
19
  ? Effect.succeed(HttpServerResponse.empty({ status: HttpStatus.fromLiteral("NotFound") }))
21
- : permissionRoute(route.permission)(handler)(request);
20
+ : permissionRoute(route.permission)(Effect.flatMap(HttpServerRequest.HttpServerRequest, handler));
22
21
  });
23
22
  }),
24
23
  );
@@ -2,7 +2,7 @@ import { Context, Layer } from "effect";
2
2
  import type { RpcMiddleware } from "effect/rpc";
3
3
  import type { Identity, SessionUser } from "@shivaedev/identity/identity.ts";
4
4
  import type { IdentityFailures } from "@shivaedev/identity/middleware.ts";
5
- import { permissionLayer } from "@shivaedev/identity/server/permissions.ts";
5
+ import { permissionLayer } from "@shivaedev/identity/server/permissionLayer.ts";
6
6
  import type { AnyAdminRegistry } from "#registry.ts";
7
7
 
8
8
  export function pagePermissions(registry: AnyAdminRegistry) {