@shivaedev/admin 0.24.2 → 0.25.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.
Files changed (151) hide show
  1. package/CHANGELOG.md +39 -0
  2. package/README.md +88 -76
  3. package/dist/Jobs.d.ts +71 -0
  4. package/dist/Jobs.d.ts.map +1 -0
  5. package/dist/Jobs.js +13 -0
  6. package/dist/Jobs.js.map +1 -0
  7. package/dist/JobsWithRetry.d.ts +92 -0
  8. package/dist/JobsWithRetry.d.ts.map +1 -0
  9. package/dist/JobsWithRetry.js +40 -0
  10. package/dist/JobsWithRetry.js.map +1 -0
  11. package/dist/Users.d.ts +35 -0
  12. package/dist/Users.d.ts.map +1 -0
  13. package/dist/Users.js +35 -0
  14. package/dist/Users.js.map +1 -0
  15. package/dist/client/adapters/SessionConfirmation.d.ts +1 -1
  16. package/dist/client/adapters/SessionConfirmation.d.ts.map +1 -1
  17. package/dist/client/adapters/SessionListView.d.ts +1 -1
  18. package/dist/client/adapters/SessionListView.d.ts.map +1 -1
  19. package/dist/client/adapters/SessionPagination.d.ts +2 -2
  20. package/dist/client/adapters/SessionPagination.d.ts.map +1 -1
  21. package/dist/client/adapters/SessionsView.d.ts +2 -2
  22. package/dist/client/adapters/SessionsView.d.ts.map +1 -1
  23. package/dist/client/adapters/UsersTable.d.ts +2 -2
  24. package/dist/client/adapters/UsersTable.d.ts.map +1 -1
  25. package/dist/client/adapters/UsersTable.js.map +1 -1
  26. package/dist/client/adapters/UsersView.d.ts +2 -2
  27. package/dist/client/adapters/UsersView.d.ts.map +1 -1
  28. package/dist/client/adapters/jobsTypes.d.ts +8 -8
  29. package/dist/client/adapters/jobsTypes.d.ts.map +1 -1
  30. package/dist/generated/Jobs.d.ts +144 -0
  31. package/dist/generated/Jobs.d.ts.map +1 -0
  32. package/dist/generated/Jobs.js +35 -0
  33. package/dist/generated/Jobs.js.map +1 -0
  34. package/dist/generated/JobsWithRetry.d.ts +182 -0
  35. package/dist/generated/JobsWithRetry.d.ts.map +1 -0
  36. package/dist/generated/JobsWithRetry.js +50 -0
  37. package/dist/generated/JobsWithRetry.js.map +1 -0
  38. package/dist/generated/Users.d.ts +65 -0
  39. package/dist/generated/Users.d.ts.map +1 -0
  40. package/dist/generated/Users.js +27 -0
  41. package/dist/generated/Users.js.map +1 -0
  42. package/dist/jobs/DeadLetter.d.ts +27 -0
  43. package/dist/jobs/DeadLetter.d.ts.map +1 -0
  44. package/dist/jobs/DeadLetter.js +11 -0
  45. package/dist/jobs/DeadLetter.js.map +1 -0
  46. package/dist/jobs/NotFailed.d.ts +9 -0
  47. package/dist/jobs/NotFailed.d.ts.map +1 -0
  48. package/dist/jobs/NotFailed.js +7 -0
  49. package/dist/jobs/NotFailed.js.map +1 -0
  50. package/dist/jobs/Page.d.ts +272 -0
  51. package/dist/jobs/Page.d.ts.map +1 -0
  52. package/dist/jobs/Page.js +10 -0
  53. package/dist/jobs/Page.js.map +1 -0
  54. package/dist/jobs/PageWithRetry.d.ts +296 -0
  55. package/dist/jobs/PageWithRetry.d.ts.map +1 -0
  56. package/dist/jobs/PageWithRetry.js +10 -0
  57. package/dist/jobs/PageWithRetry.js.map +1 -0
  58. package/dist/jobs/Row.d.ts +21 -0
  59. package/dist/jobs/Row.d.ts.map +1 -0
  60. package/dist/jobs/Row.js +5 -0
  61. package/dist/jobs/Row.js.map +1 -0
  62. package/dist/jobs/keys.d.ts +5 -5
  63. package/dist/jobs/schemas.d.ts +2 -55
  64. package/dist/jobs/schemas.d.ts.map +1 -1
  65. package/dist/jobs/schemas.js +2 -19
  66. package/dist/jobs/schemas.js.map +1 -1
  67. package/dist/page.d.ts +4 -3
  68. package/dist/page.d.ts.map +1 -1
  69. package/dist/page.js.map +1 -1
  70. package/dist/server/RegisteredQueues.d.ts +21 -0
  71. package/dist/server/RegisteredQueues.d.ts.map +1 -0
  72. package/dist/server/RegisteredQueues.js +4 -0
  73. package/dist/server/RegisteredQueues.js.map +1 -0
  74. package/dist/server/adapters/pgBossQueues.d.ts +6 -0
  75. package/dist/server/adapters/pgBossQueues.d.ts.map +1 -0
  76. package/dist/server/adapters/pgBossQueues.js +57 -0
  77. package/dist/server/adapters/pgBossQueues.js.map +1 -0
  78. package/dist/server/jobsReads.d.ts +40 -0
  79. package/dist/server/jobsReads.d.ts.map +1 -0
  80. package/dist/server/jobsReads.js +65 -0
  81. package/dist/server/jobsReads.js.map +1 -0
  82. package/dist/sessions/Page.d.ts +31 -27
  83. package/dist/sessions/Page.d.ts.map +1 -1
  84. package/dist/sessions/Page.js +1 -1
  85. package/dist/sessions/Page.js.map +1 -1
  86. package/dist/users/List.d.ts +5 -0
  87. package/dist/users/List.d.ts.map +1 -0
  88. package/dist/users/List.js +2 -0
  89. package/dist/users/List.js.map +1 -0
  90. package/dist/users/Page.d.ts +104 -0
  91. package/dist/users/Page.d.ts.map +1 -0
  92. package/dist/users/Page.js +10 -0
  93. package/dist/users/Page.js.map +1 -0
  94. package/package.json +25 -23
  95. package/src/Jobs.ts +13 -0
  96. package/src/JobsWithRetry.ts +42 -0
  97. package/src/Users.ts +38 -0
  98. package/src/client/adapters/SessionConfirmation.tsx +1 -1
  99. package/src/client/adapters/SessionListView.tsx +1 -1
  100. package/src/client/adapters/SessionPagination.tsx +2 -2
  101. package/src/client/adapters/SessionsView.ts +2 -2
  102. package/src/client/adapters/UsersTable.tsx +3 -3
  103. package/src/client/adapters/UsersView.ts +2 -2
  104. package/src/client/adapters/jobsTypes.ts +8 -8
  105. package/src/generated/Jobs.ts +40 -0
  106. package/src/generated/JobsWithRetry.ts +55 -0
  107. package/src/generated/README.md +1 -0
  108. package/src/generated/Users.ts +32 -0
  109. package/src/jobs/DeadLetter.ts +10 -0
  110. package/src/jobs/NotFailed.ts +6 -0
  111. package/src/jobs/Page.ts +10 -0
  112. package/src/jobs/PageWithRetry.ts +10 -0
  113. package/src/jobs/Row.ts +4 -0
  114. package/src/jobs/schemas.ts +2 -23
  115. package/src/page.ts +8 -9
  116. package/src/server/RegisteredQueues.ts +22 -0
  117. package/src/server/adapters/pgBossQueues.ts +94 -0
  118. package/src/server/jobsReads.ts +72 -0
  119. package/src/sessions/Page.ts +1 -1
  120. package/src/users/List.ts +3 -0
  121. package/src/users/Page.ts +10 -0
  122. package/dist/jobs/page.d.ts +0 -425
  123. package/dist/jobs/page.d.ts.map +0 -1
  124. package/dist/jobs/page.js +0 -58
  125. package/dist/jobs/page.js.map +0 -1
  126. package/dist/jobs/retryPage.d.ts +0 -480
  127. package/dist/jobs/retryPage.d.ts.map +0 -1
  128. package/dist/jobs/retryPage.js +0 -50
  129. package/dist/jobs/retryPage.js.map +0 -1
  130. package/dist/server/jobsHandlers.d.ts +0 -62
  131. package/dist/server/jobsHandlers.d.ts.map +0 -1
  132. package/dist/server/jobsHandlers.js +0 -73
  133. package/dist/server/jobsHandlers.js.map +0 -1
  134. package/dist/server/jobsHandlersWithRetry.d.ts +0 -7
  135. package/dist/server/jobsHandlersWithRetry.d.ts.map +0 -1
  136. package/dist/server/jobsHandlersWithRetry.js +0 -43
  137. package/dist/server/jobsHandlersWithRetry.js.map +0 -1
  138. package/dist/server/usersHandlers.d.ts +0 -3
  139. package/dist/server/usersHandlers.d.ts.map +0 -1
  140. package/dist/server/usersHandlers.js +0 -15
  141. package/dist/server/usersHandlers.js.map +0 -1
  142. package/dist/users/page.d.ts +0 -115
  143. package/dist/users/page.d.ts.map +0 -1
  144. package/dist/users/page.js +0 -35
  145. package/dist/users/page.js.map +0 -1
  146. package/src/jobs/page.ts +0 -58
  147. package/src/jobs/retryPage.ts +0 -54
  148. package/src/server/jobsHandlers.ts +0 -95
  149. package/src/server/jobsHandlersWithRetry.ts +0 -59
  150. package/src/server/usersHandlers.ts +0 -17
  151. package/src/users/page.ts +0 -36
@@ -0,0 +1,94 @@
1
+ import { type Context, Effect, Layer, Option, type Schema } from "effect";
2
+ import { BadRequest } from "@shivaedev/errors/taxonomy.ts";
3
+ import type { PgBossError, PgBossPayloadError } from "@shivaedev/jobs/server/error.ts";
4
+ import type { PgBossService } from "@shivaedev/jobs/server/service.ts";
5
+ import { type JobsEntry, type JobsPayload, jobsQueue } from "#jobs/entry.ts";
6
+ import { JobsNotFailed } from "#jobs/NotFailed.ts";
7
+ import { JobsPayloadInvalid, JobsQueueUnregistered, JobsUnavailable } from "#jobs/schemas.ts";
8
+ import { RegisteredQueues } from "#server/RegisteredQueues.ts";
9
+
10
+ type Declared<E> = E extends Schema.SchemaError
11
+ ? BadRequest
12
+ : E extends PgBossPayloadError
13
+ ? JobsPayloadInvalid
14
+ : E extends PgBossError
15
+ ? JobsUnavailable
16
+ : never;
17
+
18
+ function jobsFailures<A, E extends PgBossError | PgBossPayloadError | Schema.SchemaError, R>(
19
+ effect: Effect.Effect<A, E, R>,
20
+ ): Effect.Effect<A, Declared<E>, R>;
21
+ function jobsFailures<A, R>(
22
+ effect: Effect.Effect<A, PgBossError | PgBossPayloadError | Schema.SchemaError, R>,
23
+ ): Effect.Effect<A, BadRequest | JobsPayloadInvalid | JobsUnavailable, R> {
24
+ return effect.pipe(
25
+ Effect.mapError((error) => {
26
+ switch (error._tag) {
27
+ case "SchemaError":
28
+ return new BadRequest({ message: "Invalid job page options" });
29
+ case "PgBossPayloadError":
30
+ return new JobsPayloadInvalid({ queue: error.queue });
31
+ case "PgBossError":
32
+ return new JobsUnavailable({ operation: error.operation });
33
+ }
34
+ }),
35
+ );
36
+ }
37
+
38
+ // The Layer keeps the queue schemas' decoding services, so the page's operations require only RegisteredQueues.
39
+ export function pgBossQueues<const TQueues extends readonly JobsEntry[], TService>(
40
+ service: Context.Service<TService, PgBossService>,
41
+ ...queues: TQueues
42
+ ) {
43
+ return Layer.effect(
44
+ RegisteredQueues,
45
+ Effect.gen(function* () {
46
+ const runtime = yield* service;
47
+ const inspection = yield* runtime.inspection();
48
+ const decoding = yield* Effect.context<JobsPayload<TQueues[number]>["DecodingServices"]>();
49
+ const entries: readonly TQueues[number][] = queues;
50
+ function registered(name: string) {
51
+ const entry = entries.find((candidate) => candidate.name === name);
52
+ return entry === undefined ? Effect.fail(new JobsQueueUnregistered({ queue: name })) : Effect.succeed(jobsQueue(entry));
53
+ }
54
+ function decoded<A, E>(effect: Effect.Effect<A, E, JobsPayload<TQueues[number]>["DecodingServices"]>) {
55
+ return Effect.provideContext(effect, decoding);
56
+ }
57
+ return RegisteredQueues.of({
58
+ counts: (queue) => Effect.flatMap(registered(queue), (definition) => jobsFailures(inspection.counts(definition))),
59
+ deadLetteredJobs: (queue, options) =>
60
+ Effect.flatMap(registered(queue), (definition) =>
61
+ decoded(jobsFailures(inspection.deadLetteredJobs<string, JobsPayload<TQueues[number]>>(definition, options))),
62
+ ),
63
+ failedJobs: (queue, options) =>
64
+ Effect.flatMap(registered(queue), (definition) =>
65
+ decoded(jobsFailures(inspection.failedJobs<string, JobsPayload<TQueues[number]>>(definition, options))),
66
+ ),
67
+ getJob: (queue, id) =>
68
+ Effect.flatMap(registered(queue), (definition) =>
69
+ decoded(jobsFailures(inspection.getJob<string, JobsPayload<TQueues[number]>>(definition, id))),
70
+ ),
71
+ health: () => jobsFailures(inspection.health(queues)),
72
+ retry: (queue, id) =>
73
+ Effect.gen(function* () {
74
+ const definition = yield* registered(queue);
75
+ const job = yield* decoded(jobsFailures(inspection.getJob<string, JobsPayload<TQueues[number]>>(definition, id)));
76
+ if (Option.isNone(job) || job.value.state !== "failed") {
77
+ return yield* new JobsNotFailed({ id, queue });
78
+ }
79
+ yield* jobsFailures(runtime.retry(definition, id));
80
+ }),
81
+ runScheduleNow: (name) => {
82
+ const schedule = entries.find((candidate) => candidate.name === name && !("schema" in candidate));
83
+ if (schedule === undefined || "schema" in schedule) {
84
+ return Effect.fail(new JobsQueueUnregistered({ queue: name }));
85
+ }
86
+ return runtime.runScheduleNow({ name: schedule.name, scheduleOptions: schedule.scheduleOptions ?? {} }).pipe(
87
+ Effect.catchTag("PgBossNotFoundError", () => Effect.fail(new JobsQueueUnregistered({ queue: name }))),
88
+ Effect.catchTag("PgBossError", (error) => Effect.fail(new JobsUnavailable({ operation: error.operation }))),
89
+ );
90
+ },
91
+ });
92
+ }),
93
+ );
94
+ }
@@ -0,0 +1,72 @@
1
+ import { DateTime, Effect, Option, Schema } from "effect";
2
+ import { query } from "@shivaedev/contract/operation.ts";
3
+ import type { JobPage } from "@shivaedev/jobs/server/health.ts";
4
+ import { readJobFailure } from "@shivaedev/jobs/server/readJobFailure.ts";
5
+ import { JobsDeadLetter } from "#jobs/DeadLetter.ts";
6
+ import { jobsKeys } from "#jobs/keys.ts";
7
+ import { JobsRow } from "#jobs/Row.ts";
8
+ import { JobsPayloadInvalid, PageFields } from "#jobs/schemas.ts";
9
+ import { RegisteredQueues } from "#server/RegisteredQueues.ts";
10
+
11
+ export const Health = query("health", {
12
+ reads: () => [jobsKeys.health.list],
13
+ *run() {
14
+ return yield* (yield* RegisteredQueues).health();
15
+ },
16
+ });
17
+
18
+ export const Counts = query("counts", {
19
+ payload: { queue: Schema.String },
20
+ reads: ({ queue }) => [jobsKeys.counts.item(queue)],
21
+ *run({ queue }) {
22
+ return yield* (yield* RegisteredQueues).counts(queue);
23
+ },
24
+ });
25
+
26
+ export const Failed = query("failed", {
27
+ payload: { ...PageFields, queue: Schema.String },
28
+ reads: ({ queue }) => [jobsKeys.failed.item(queue)],
29
+ *run({ queue, ...options }) {
30
+ const page = yield* (yield* RegisteredQueues).failedJobs(queue, options);
31
+ const rows: JobPage<JobsRow> = { jobs: page.jobs.map((job) => new JobsRow(job)), next: page.next };
32
+ return rows;
33
+ },
34
+ });
35
+
36
+ export const DeadLettered = query("deadLettered", {
37
+ payload: { ...PageFields, queue: Schema.String },
38
+ reads: ({ queue }) => [jobsKeys.deadLettered.item(queue)],
39
+ *run({ queue, ...options }) {
40
+ const page = yield* (yield* RegisteredQueues).deadLetteredJobs(queue, options);
41
+ const copies: JobPage<JobsDeadLetter> = { jobs: page.jobs.map((job) => new JobsDeadLetter(job)), next: page.next };
42
+ return copies;
43
+ },
44
+ });
45
+
46
+ export const Detail = query("job", {
47
+ payload: { id: Schema.String, queue: Schema.String },
48
+ reads: ({ queue, id }) => [jobsKeys.job(queue).item(id)],
49
+ *run({ id, queue }) {
50
+ const found = yield* (yield* RegisteredQueues).getJob(queue, id);
51
+ if (Option.isNone(found)) {
52
+ return Option.none<JobsRow>();
53
+ }
54
+ const job = found.value;
55
+ const output = yield* readJobFailure(queue, job.output).pipe(Effect.mapError(() => new JobsPayloadInvalid({ queue })));
56
+ return Option.some(
57
+ new JobsRow({
58
+ attempt: job.startedOn === null ? 0 : job.retryCount + 1,
59
+ completedOn: Option.map(Option.fromNullishOr(job.completedOn), DateTime.makeUnsafe),
60
+ createdOn: DateTime.makeUnsafe(job.createdOn),
61
+ data: job.data,
62
+ id: job.id,
63
+ output,
64
+ queue: job.name,
65
+ retryCount: job.retryCount,
66
+ retryLimit: job.retryLimit,
67
+ startedOn: Option.map(Option.fromNullishOr(job.startedOn), DateTime.makeUnsafe),
68
+ state: job.state,
69
+ }),
70
+ );
71
+ },
72
+ });
@@ -1,5 +1,5 @@
1
+ import { Sessions } from "@shivaedev/identity/generated/Sessions.ts";
1
2
  import { SessionsPermission } from "@shivaedev/identity/sessionPermissions.ts";
2
- import { Sessions } from "@shivaedev/identity/sessions.ts";
3
3
  import { adminPage } from "#page.ts";
4
4
 
5
5
  export const SessionsPage = adminPage({
@@ -0,0 +1,3 @@
1
+ import type { UserList } from "@shivaedev/identity/users.ts";
2
+
3
+ export type UsersList = typeof UserList.Type & { readonly canChangeRoles: boolean };
@@ -0,0 +1,10 @@
1
+ import { Users } from "#generated/Users.ts";
2
+ import { adminPage } from "#page.ts";
3
+ import { UsersPermission } from "#permissions.ts";
4
+
5
+ export const UsersPage = adminPage({
6
+ contract: Users,
7
+ id: "users",
8
+ permission: UsersPermission,
9
+ route: { path: "/admin/users", title: "Users" },
10
+ });
@@ -1,425 +0,0 @@
1
- import { Effect, Schema } from "effect";
2
- import { type JobsEntry } from "#jobs/entry.ts";
3
- import { JobsPermission } from "#permissions.ts";
4
- export declare function jobsPage<const TQueues extends readonly JobsEntry[]>(...queues: TQueues): import("#page.ts").AdminPage & {
5
- readonly route: {
6
- readonly path: "/admin/jobs";
7
- readonly title: "Jobs";
8
- } & {
9
- readonly permission: import("@shivaedev/access/permission.ts").Permission;
10
- };
11
- readonly id: "jobs";
12
- readonly permissionKey: string;
13
- readonly contract: import("@shivaedev/contract/contract.ts").Contract<"admin.jobs", readonly [Omit<NoInfer<import("@shivaedev/contract/operation.ts").Query<"health", Schema.Void, Schema.Struct<{
14
- readonly activeTotal: Schema.Number;
15
- readonly deadLetteredTotal: Schema.Number;
16
- readonly failedTotal: Schema.Number;
17
- readonly jobs: Schema.$Array<Schema.Struct<{
18
- readonly activeCount: Schema.Number;
19
- readonly deadLetteredCount: Schema.Number;
20
- readonly failedCount: Schema.Number;
21
- readonly name: Schema.String;
22
- readonly queuedCount: Schema.Number;
23
- readonly readyCount: Schema.Number;
24
- }>>;
25
- readonly queuedTotal: Schema.Number;
26
- readonly readyTotal: Schema.Number;
27
- }>, {
28
- BadRequest: typeof import("@shivaedev/errors/taxonomy.ts").BadRequest;
29
- JobsPayloadInvalid: typeof import("#jobs/schemas.ts").JobsPayloadInvalid;
30
- JobsQueueUnregistered: typeof import("#jobs/schemas.ts").JobsQueueUnregistered;
31
- JobsUnavailable: typeof import("#jobs/schemas.ts").JobsUnavailable;
32
- }, never>>, "readPolicy"> & {
33
- readonly readPolicy: import("@shivaedev/contract/readPolicy.ts").QueryReadPolicy<void, import("@shivaedev/errors/taxonomy.ts").BadRequest | import("#jobs/schemas.ts").JobsPayloadInvalid | import("#jobs/schemas.ts").JobsQueueUnregistered | import("#jobs/schemas.ts").JobsUnavailable, import("@shivaedev/identity/identity.ts").SessionUser>;
34
- }, Omit<NoInfer<import("@shivaedev/contract/operation.ts").Query<"counts", Schema.Struct<{
35
- queue: Schema.String;
36
- }>, Schema.Struct<{
37
- readonly activeCount: Schema.Number;
38
- readonly failedCount: Schema.Number;
39
- readonly queuedCount: Schema.Number;
40
- readonly totalCount: Schema.Number;
41
- }>, {
42
- BadRequest: typeof import("@shivaedev/errors/taxonomy.ts").BadRequest;
43
- JobsPayloadInvalid: typeof import("#jobs/schemas.ts").JobsPayloadInvalid;
44
- JobsQueueUnregistered: typeof import("#jobs/schemas.ts").JobsQueueUnregistered;
45
- JobsUnavailable: typeof import("#jobs/schemas.ts").JobsUnavailable;
46
- }, never>>, "readPolicy"> & {
47
- readonly readPolicy: import("@shivaedev/contract/readPolicy.ts").QueryReadPolicy<{
48
- readonly queue: string;
49
- }, import("@shivaedev/errors/taxonomy.ts").BadRequest | import("#jobs/schemas.ts").JobsPayloadInvalid | import("#jobs/schemas.ts").JobsQueueUnregistered | import("#jobs/schemas.ts").JobsUnavailable, import("@shivaedev/identity/identity.ts").SessionUser>;
50
- }, Omit<NoInfer<import("@shivaedev/contract/operation.ts").Query<"failed", Schema.Struct<{
51
- cursor: Schema.optionalKey<Schema.String>;
52
- limit: Schema.Number;
53
- queue: Schema.String;
54
- }>, Schema.Struct<{
55
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
56
- readonly attempt: Schema.Number;
57
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
58
- readonly createdOn: Schema.DateTimeUtcFromString;
59
- readonly id: Schema.String;
60
- readonly output: Schema.NullOr<Schema.Struct<{
61
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
62
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
63
- }>>;
64
- readonly retryCount: Schema.Number;
65
- readonly retryLimit: Schema.Number;
66
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
67
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
68
- readonly data: Schema.Unknown;
69
- readonly queue: Schema.Literal<string>;
70
- }>[]>>;
71
- readonly next: Schema.OptionFromNullOr<Schema.String>;
72
- }>, {
73
- BadRequest: typeof import("@shivaedev/errors/taxonomy.ts").BadRequest;
74
- JobsPayloadInvalid: typeof import("#jobs/schemas.ts").JobsPayloadInvalid;
75
- JobsQueueUnregistered: typeof import("#jobs/schemas.ts").JobsQueueUnregistered;
76
- JobsUnavailable: typeof import("#jobs/schemas.ts").JobsUnavailable;
77
- }, never>>, "readPolicy"> & {
78
- readonly readPolicy: import("@shivaedev/contract/readPolicy.ts").QueryReadPolicy<{
79
- readonly cursor?: string;
80
- readonly limit: number;
81
- readonly queue: string;
82
- }, import("@shivaedev/errors/taxonomy.ts").BadRequest | import("#jobs/schemas.ts").JobsPayloadInvalid | import("#jobs/schemas.ts").JobsQueueUnregistered | import("#jobs/schemas.ts").JobsUnavailable, import("@shivaedev/identity/identity.ts").SessionUser>;
83
- }, Omit<NoInfer<import("@shivaedev/contract/operation.ts").Query<"deadLettered", Schema.Struct<{
84
- cursor: Schema.optionalKey<Schema.String>;
85
- limit: Schema.Number;
86
- queue: Schema.String;
87
- }>, Schema.Struct<{
88
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
89
- readonly attempt: Schema.Number;
90
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
91
- readonly createdOn: Schema.DateTimeUtcFromString;
92
- readonly id: Schema.String;
93
- readonly output: Schema.NullOr<Schema.Struct<{
94
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
95
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
96
- }>>;
97
- readonly retryCount: Schema.Number;
98
- readonly retryLimit: Schema.Number;
99
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
100
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
101
- readonly data: Schema.Unknown;
102
- readonly queue: Schema.Literal<string>;
103
- readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
104
- readonly sourceOutput: Schema.NullOr<Schema.Struct<{
105
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
106
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
107
- }>>;
108
- readonly sourceQueue: Schema.Literal<string>;
109
- }>[]>>;
110
- readonly next: Schema.OptionFromNullOr<Schema.String>;
111
- }>, {
112
- BadRequest: typeof import("@shivaedev/errors/taxonomy.ts").BadRequest;
113
- JobsPayloadInvalid: typeof import("#jobs/schemas.ts").JobsPayloadInvalid;
114
- JobsQueueUnregistered: typeof import("#jobs/schemas.ts").JobsQueueUnregistered;
115
- JobsUnavailable: typeof import("#jobs/schemas.ts").JobsUnavailable;
116
- }, never>>, "readPolicy"> & {
117
- readonly readPolicy: import("@shivaedev/contract/readPolicy.ts").QueryReadPolicy<{
118
- readonly cursor?: string;
119
- readonly limit: number;
120
- readonly queue: string;
121
- }, import("@shivaedev/errors/taxonomy.ts").BadRequest | import("#jobs/schemas.ts").JobsPayloadInvalid | import("#jobs/schemas.ts").JobsQueueUnregistered | import("#jobs/schemas.ts").JobsUnavailable, import("@shivaedev/identity/identity.ts").SessionUser>;
122
- }, Omit<NoInfer<import("@shivaedev/contract/operation.ts").Query<"job", Schema.Struct<{
123
- id: Schema.String;
124
- queue: Schema.String;
125
- }>, Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
126
- readonly attempt: Schema.Number;
127
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
128
- readonly createdOn: Schema.DateTimeUtcFromString;
129
- readonly id: Schema.String;
130
- readonly output: Schema.NullOr<Schema.Struct<{
131
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
132
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
133
- }>>;
134
- readonly retryCount: Schema.Number;
135
- readonly retryLimit: Schema.Number;
136
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
137
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
138
- readonly data: Schema.Unknown;
139
- readonly queue: Schema.Literal<string>;
140
- }>[]>>, {
141
- BadRequest: typeof import("@shivaedev/errors/taxonomy.ts").BadRequest;
142
- JobsPayloadInvalid: typeof import("#jobs/schemas.ts").JobsPayloadInvalid;
143
- JobsQueueUnregistered: typeof import("#jobs/schemas.ts").JobsQueueUnregistered;
144
- JobsUnavailable: typeof import("#jobs/schemas.ts").JobsUnavailable;
145
- }, never>>, "readPolicy"> & {
146
- readonly readPolicy: import("@shivaedev/contract/readPolicy.ts").QueryReadPolicy<{
147
- readonly id: string;
148
- readonly queue: string;
149
- }, import("@shivaedev/errors/taxonomy.ts").BadRequest | import("#jobs/schemas.ts").JobsPayloadInvalid | import("#jobs/schemas.ts").JobsQueueUnregistered | import("#jobs/schemas.ts").JobsUnavailable, import("@shivaedev/identity/identity.ts").SessionUser>;
150
- }], readonly [], import("effect/rpc/Rpc").Rpc<"admin.jobs.$changes", Schema.Struct<{
151
- queries: Schema.$Array<Schema.Union<readonly (Schema.Struct<{
152
- query: Schema.Literal<"counts">;
153
- payload: Schema.Struct<{
154
- queue: Schema.String;
155
- }>;
156
- }> | Schema.Struct<{
157
- query: Schema.Literal<"deadLettered">;
158
- payload: Schema.Struct<{
159
- cursor: Schema.optionalKey<Schema.String>;
160
- limit: Schema.Number;
161
- queue: Schema.String;
162
- }>;
163
- }> | Schema.Struct<{
164
- query: Schema.Literal<"failed">;
165
- payload: Schema.Struct<{
166
- cursor: Schema.optionalKey<Schema.String>;
167
- limit: Schema.Number;
168
- queue: Schema.String;
169
- }>;
170
- }> | Schema.Struct<{
171
- query: Schema.Literal<"health">;
172
- payload: Schema.Void;
173
- }> | Schema.Struct<{
174
- query: Schema.Literal<"job">;
175
- payload: Schema.Struct<{
176
- id: Schema.String;
177
- queue: Schema.String;
178
- }>;
179
- }>)[]>>;
180
- }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied, ...(Schema.Struct<{
181
- readonly _tag: Schema.Literal<"Unchanged">;
182
- readonly queryIndex: Schema.Number;
183
- }> | Schema.Struct<{
184
- _tag: Schema.Literal<"Result">;
185
- query: Schema.Literal<"counts">;
186
- queryIndex: Schema.Number;
187
- value: Schema.Struct<{
188
- readonly activeCount: Schema.Number;
189
- readonly failedCount: Schema.Number;
190
- readonly queuedCount: Schema.Number;
191
- readonly totalCount: Schema.Number;
192
- }>;
193
- }> | Schema.Struct<{
194
- _tag: Schema.Literal<"Result">;
195
- query: Schema.Literal<"deadLettered">;
196
- queryIndex: Schema.Number;
197
- value: Schema.Struct<{
198
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
199
- readonly attempt: Schema.Number;
200
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
201
- readonly createdOn: Schema.DateTimeUtcFromString;
202
- readonly id: Schema.String;
203
- readonly output: Schema.NullOr<Schema.Struct<{
204
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
205
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
206
- }>>;
207
- readonly retryCount: Schema.Number;
208
- readonly retryLimit: Schema.Number;
209
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
210
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
211
- readonly data: Schema.Unknown;
212
- readonly queue: Schema.Literal<string>;
213
- readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
214
- readonly sourceOutput: Schema.NullOr<Schema.Struct<{
215
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
216
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
217
- }>>;
218
- readonly sourceQueue: Schema.Literal<string>;
219
- }>[]>>;
220
- readonly next: Schema.OptionFromNullOr<Schema.String>;
221
- }>;
222
- }> | Schema.Struct<{
223
- _tag: Schema.Literal<"Result">;
224
- query: Schema.Literal<"failed">;
225
- queryIndex: Schema.Number;
226
- value: Schema.Struct<{
227
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
228
- readonly attempt: Schema.Number;
229
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
230
- readonly createdOn: Schema.DateTimeUtcFromString;
231
- readonly id: Schema.String;
232
- readonly output: Schema.NullOr<Schema.Struct<{
233
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
234
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
235
- }>>;
236
- readonly retryCount: Schema.Number;
237
- readonly retryLimit: Schema.Number;
238
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
239
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
240
- readonly data: Schema.Unknown;
241
- readonly queue: Schema.Literal<string>;
242
- }>[]>>;
243
- readonly next: Schema.OptionFromNullOr<Schema.String>;
244
- }>;
245
- }> | Schema.Struct<{
246
- _tag: Schema.Literal<"Result">;
247
- query: Schema.Literal<"health">;
248
- queryIndex: Schema.Number;
249
- value: Schema.Struct<{
250
- readonly activeTotal: Schema.Number;
251
- readonly deadLetteredTotal: Schema.Number;
252
- readonly failedTotal: Schema.Number;
253
- readonly jobs: Schema.$Array<Schema.Struct<{
254
- readonly activeCount: Schema.Number;
255
- readonly deadLetteredCount: Schema.Number;
256
- readonly failedCount: Schema.Number;
257
- readonly name: Schema.String;
258
- readonly queuedCount: Schema.Number;
259
- readonly readyCount: Schema.Number;
260
- }>>;
261
- readonly queuedTotal: Schema.Number;
262
- readonly readyTotal: Schema.Number;
263
- }>;
264
- }> | Schema.Struct<{
265
- _tag: Schema.Literal<"Result">;
266
- query: Schema.Literal<"job">;
267
- queryIndex: Schema.Number;
268
- value: Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
269
- readonly attempt: Schema.Number;
270
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
271
- readonly createdOn: Schema.DateTimeUtcFromString;
272
- readonly id: Schema.String;
273
- readonly output: Schema.NullOr<Schema.Struct<{
274
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
275
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
276
- }>>;
277
- readonly retryCount: Schema.Number;
278
- readonly retryLimit: Schema.Number;
279
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
280
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
281
- readonly data: Schema.Unknown;
282
- readonly queue: Schema.Literal<string>;
283
- }>[]>>;
284
- }>)[]]>, 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: {
285
- readonly rpc: import("effect/rpc/Rpc").Any;
286
- readonly payload: unknown;
287
- }) => 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>> & {
288
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
289
- "~ClientError": never;
290
- 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]>;
291
- requiredForClient: false;
292
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.counts", Schema.Struct<{
293
- queue: Schema.String;
294
- }>, Schema.Struct<{
295
- readonly activeCount: Schema.Number;
296
- readonly failedCount: Schema.Number;
297
- readonly queuedCount: Schema.Number;
298
- readonly totalCount: Schema.Number;
299
- }>, Schema.Union<readonly [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)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
300
- readonly rpc: import("effect/rpc/Rpc").Any;
301
- readonly payload: unknown;
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>> & {
303
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
304
- "~ClientError": never;
305
- 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]>;
306
- requiredForClient: false;
307
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.deadLettered", Schema.Struct<{
308
- cursor: Schema.optionalKey<Schema.String>;
309
- limit: Schema.Number;
310
- queue: Schema.String;
311
- }>, Schema.Struct<{
312
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
313
- readonly attempt: Schema.Number;
314
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
315
- readonly createdOn: Schema.DateTimeUtcFromString;
316
- readonly id: Schema.String;
317
- readonly output: Schema.NullOr<Schema.Struct<{
318
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
319
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
320
- }>>;
321
- readonly retryCount: Schema.Number;
322
- readonly retryLimit: Schema.Number;
323
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
324
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
325
- readonly data: Schema.Unknown;
326
- readonly queue: Schema.Literal<string>;
327
- readonly sourceId: Schema.OptionFromNullOr<Schema.String>;
328
- readonly sourceOutput: Schema.NullOr<Schema.Struct<{
329
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
330
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
331
- }>>;
332
- readonly sourceQueue: Schema.Literal<string>;
333
- }>[]>>;
334
- readonly next: Schema.OptionFromNullOr<Schema.String>;
335
- }>, Schema.Union<readonly [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)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
336
- readonly rpc: import("effect/rpc/Rpc").Any;
337
- readonly payload: unknown;
338
- }) => 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>> & {
339
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
340
- "~ClientError": never;
341
- 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]>;
342
- requiredForClient: false;
343
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.failed", Schema.Struct<{
344
- cursor: Schema.optionalKey<Schema.String>;
345
- limit: Schema.Number;
346
- queue: Schema.String;
347
- }>, Schema.Struct<{
348
- readonly jobs: Schema.$Array<Schema.Union<Schema.Struct<{
349
- readonly attempt: Schema.Number;
350
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
351
- readonly createdOn: Schema.DateTimeUtcFromString;
352
- readonly id: Schema.String;
353
- readonly output: Schema.NullOr<Schema.Struct<{
354
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
355
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
356
- }>>;
357
- readonly retryCount: Schema.Number;
358
- readonly retryLimit: Schema.Number;
359
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
360
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
361
- readonly data: Schema.Unknown;
362
- readonly queue: Schema.Literal<string>;
363
- }>[]>>;
364
- readonly next: Schema.OptionFromNullOr<Schema.String>;
365
- }>, Schema.Union<readonly [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)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
366
- readonly rpc: import("effect/rpc/Rpc").Any;
367
- readonly payload: unknown;
368
- }) => 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>> & {
369
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
370
- "~ClientError": never;
371
- 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]>;
372
- requiredForClient: false;
373
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.health", Schema.Void, Schema.Struct<{
374
- readonly activeTotal: Schema.Number;
375
- readonly deadLetteredTotal: Schema.Number;
376
- readonly failedTotal: Schema.Number;
377
- readonly jobs: Schema.$Array<Schema.Struct<{
378
- readonly activeCount: Schema.Number;
379
- readonly deadLetteredCount: Schema.Number;
380
- readonly failedCount: Schema.Number;
381
- readonly name: Schema.String;
382
- readonly queuedCount: Schema.Number;
383
- readonly readyCount: Schema.Number;
384
- }>>;
385
- readonly queuedTotal: Schema.Number;
386
- readonly readyTotal: Schema.Number;
387
- }>, Schema.Union<readonly [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)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
388
- readonly rpc: import("effect/rpc/Rpc").Any;
389
- readonly payload: unknown;
390
- }) => 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>> & {
391
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
392
- "~ClientError": never;
393
- 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]>;
394
- requiredForClient: false;
395
- }), never> | import("effect/rpc/Rpc").Rpc<"admin.jobs.job", Schema.Struct<{
396
- id: Schema.String;
397
- queue: Schema.String;
398
- }>, Schema.OptionFromNullOr<Schema.Union<Schema.Struct<{
399
- readonly attempt: Schema.Number;
400
- readonly completedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
401
- readonly createdOn: Schema.DateTimeUtcFromString;
402
- readonly id: Schema.String;
403
- readonly output: Schema.NullOr<Schema.Struct<{
404
- readonly _tag: Schema.withDecodingDefaultKey<Schema.String, never>;
405
- readonly message: Schema.decodeTo<Schema.String, Schema.String, never, never>;
406
- }>>;
407
- readonly retryCount: Schema.Number;
408
- readonly retryLimit: Schema.Number;
409
- readonly startedOn: Schema.OptionFromNullOr<Schema.DateTimeUtcFromString>;
410
- readonly state: Schema.Literals<readonly ["created", "retry", "active", "completed", "cancelled", "failed"]>;
411
- readonly data: Schema.Unknown;
412
- readonly queue: Schema.Literal<string>;
413
- }>[]>>, Schema.Union<readonly [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)[]>, typeof import("@shivaedev/contract/readPolicyErrors.ts").QueryReadDenied]>, typeof JobsPermission | (import("effect/Context").Reference<<A, E, R>(effect: Effect.Effect<A, E, R>, request: {
414
- readonly rpc: import("effect/rpc/Rpc").Any;
415
- readonly payload: unknown;
416
- }) => 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>> & {
417
- "~effect/rpc/RpcMiddleware": "~effect/rpc/RpcMiddleware";
418
- "~ClientError": never;
419
- 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]>;
420
- requiredForClient: false;
421
- }), never>, readonly [], undefined>;
422
- } & {
423
- queues: TQueues;
424
- };
425
- //# sourceMappingURL=page.d.ts.map
@@ -1 +0,0 @@
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"}