@tashks/core 0.1.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/LICENSE +21 -0
- package/dist/src/query.d.ts +294 -0
- package/dist/src/query.d.ts.map +1 -0
- package/dist/src/query.js +303 -0
- package/dist/src/query.test.d.ts +2 -0
- package/dist/src/query.test.d.ts.map +1 -0
- package/dist/src/query.test.js +673 -0
- package/dist/src/repository.d.ts +100 -0
- package/dist/src/repository.d.ts.map +1 -0
- package/dist/src/repository.js +742 -0
- package/dist/src/repository.test.d.ts +2 -0
- package/dist/src/repository.test.d.ts.map +1 -0
- package/dist/src/repository.test.js +1439 -0
- package/dist/src/schema.d.ts +460 -0
- package/dist/src/schema.d.ts.map +1 -0
- package/dist/src/schema.js +166 -0
- package/dist/src/schema.test.d.ts +2 -0
- package/dist/src/schema.test.d.ts.map +1 -0
- package/dist/src/schema.test.js +123 -0
- package/dist/tsconfig.tsbuildinfo +1 -0
- package/package.json +43 -0
|
@@ -0,0 +1,460 @@
|
|
|
1
|
+
import * as Schema from "effect/Schema";
|
|
2
|
+
export declare const TaskStatus: Schema.Literal<
|
|
3
|
+
["active", "backlog", "blocked", "done", "dropped", "on-hold"]
|
|
4
|
+
>;
|
|
5
|
+
export type TaskStatus = Schema.Schema.Type<typeof TaskStatus>;
|
|
6
|
+
export declare const TaskArea: Schema.Literal<
|
|
7
|
+
[
|
|
8
|
+
"health",
|
|
9
|
+
"infrastructure",
|
|
10
|
+
"work",
|
|
11
|
+
"personal",
|
|
12
|
+
"blog",
|
|
13
|
+
"code",
|
|
14
|
+
"home",
|
|
15
|
+
"side-projects",
|
|
16
|
+
]
|
|
17
|
+
>;
|
|
18
|
+
export type TaskArea = Schema.Schema.Type<typeof TaskArea>;
|
|
19
|
+
export declare const TaskUrgency: Schema.Literal<
|
|
20
|
+
["low", "medium", "high", "urgent", "critical"]
|
|
21
|
+
>;
|
|
22
|
+
export type TaskUrgency = Schema.Schema.Type<typeof TaskUrgency>;
|
|
23
|
+
export declare const TaskEnergy: Schema.Literal<["low", "medium", "high"]>;
|
|
24
|
+
export type TaskEnergy = Schema.Schema.Type<typeof TaskEnergy>;
|
|
25
|
+
export declare const Subtask: Schema.Struct<{
|
|
26
|
+
text: typeof Schema.String;
|
|
27
|
+
done: typeof Schema.Boolean;
|
|
28
|
+
}>;
|
|
29
|
+
export type Subtask = Schema.Schema.Type<typeof Subtask>;
|
|
30
|
+
export declare const TaskRecurrenceTrigger: Schema.Literal<
|
|
31
|
+
["clock", "completion"]
|
|
32
|
+
>;
|
|
33
|
+
export type TaskRecurrenceTrigger = Schema.Schema.Type<
|
|
34
|
+
typeof TaskRecurrenceTrigger
|
|
35
|
+
>;
|
|
36
|
+
export declare const TaskRecurrenceStrategy: Schema.Literal<
|
|
37
|
+
["replace", "accumulate"]
|
|
38
|
+
>;
|
|
39
|
+
export type TaskRecurrenceStrategy = Schema.Schema.Type<
|
|
40
|
+
typeof TaskRecurrenceStrategy
|
|
41
|
+
>;
|
|
42
|
+
export declare const Task: Schema.Struct<{
|
|
43
|
+
id: typeof Schema.String;
|
|
44
|
+
title: typeof Schema.String;
|
|
45
|
+
status: Schema.Literal<
|
|
46
|
+
["active", "backlog", "blocked", "done", "dropped", "on-hold"]
|
|
47
|
+
>;
|
|
48
|
+
area: Schema.Literal<
|
|
49
|
+
[
|
|
50
|
+
"health",
|
|
51
|
+
"infrastructure",
|
|
52
|
+
"work",
|
|
53
|
+
"personal",
|
|
54
|
+
"blog",
|
|
55
|
+
"code",
|
|
56
|
+
"home",
|
|
57
|
+
"side-projects",
|
|
58
|
+
]
|
|
59
|
+
>;
|
|
60
|
+
project: Schema.NullOr<typeof Schema.String>;
|
|
61
|
+
tags: Schema.Array$<typeof Schema.String>;
|
|
62
|
+
created: typeof Schema.String;
|
|
63
|
+
updated: typeof Schema.String;
|
|
64
|
+
urgency: Schema.Literal<["low", "medium", "high", "urgent", "critical"]>;
|
|
65
|
+
energy: Schema.Literal<["low", "medium", "high"]>;
|
|
66
|
+
due: Schema.NullOr<typeof Schema.String>;
|
|
67
|
+
context: typeof Schema.String;
|
|
68
|
+
subtasks: Schema.Array$<
|
|
69
|
+
Schema.Struct<{
|
|
70
|
+
text: typeof Schema.String;
|
|
71
|
+
done: typeof Schema.Boolean;
|
|
72
|
+
}>
|
|
73
|
+
>;
|
|
74
|
+
blocked_by: Schema.Array$<typeof Schema.String>;
|
|
75
|
+
estimated_minutes: Schema.NullOr<typeof Schema.Number>;
|
|
76
|
+
actual_minutes: Schema.NullOr<typeof Schema.Number>;
|
|
77
|
+
completed_at: Schema.NullOr<typeof Schema.String>;
|
|
78
|
+
last_surfaced: Schema.NullOr<typeof Schema.String>;
|
|
79
|
+
defer_until: Schema.NullOr<typeof Schema.String>;
|
|
80
|
+
nudge_count: typeof Schema.Number;
|
|
81
|
+
recurrence: Schema.NullOr<typeof Schema.String>;
|
|
82
|
+
recurrence_trigger: Schema.Literal<["clock", "completion"]>;
|
|
83
|
+
recurrence_strategy: Schema.Literal<["replace", "accumulate"]>;
|
|
84
|
+
recurrence_last_generated: Schema.NullOr<typeof Schema.String>;
|
|
85
|
+
}>;
|
|
86
|
+
export type Task = Schema.Schema.Type<typeof Task>;
|
|
87
|
+
export declare const TaskCreateInput: Schema.Struct<{
|
|
88
|
+
title: typeof Schema.String;
|
|
89
|
+
status: Schema.optionalWith<
|
|
90
|
+
Schema.Literal<
|
|
91
|
+
["active", "backlog", "blocked", "done", "dropped", "on-hold"]
|
|
92
|
+
>,
|
|
93
|
+
{
|
|
94
|
+
default: () => "active";
|
|
95
|
+
}
|
|
96
|
+
>;
|
|
97
|
+
area: Schema.optionalWith<
|
|
98
|
+
Schema.Literal<
|
|
99
|
+
[
|
|
100
|
+
"health",
|
|
101
|
+
"infrastructure",
|
|
102
|
+
"work",
|
|
103
|
+
"personal",
|
|
104
|
+
"blog",
|
|
105
|
+
"code",
|
|
106
|
+
"home",
|
|
107
|
+
"side-projects",
|
|
108
|
+
]
|
|
109
|
+
>,
|
|
110
|
+
{
|
|
111
|
+
default: () => "personal";
|
|
112
|
+
}
|
|
113
|
+
>;
|
|
114
|
+
project: Schema.optionalWith<
|
|
115
|
+
Schema.NullOr<typeof Schema.String>,
|
|
116
|
+
{
|
|
117
|
+
default: () => null;
|
|
118
|
+
}
|
|
119
|
+
>;
|
|
120
|
+
tags: Schema.optionalWith<
|
|
121
|
+
Schema.Array$<typeof Schema.String>,
|
|
122
|
+
{
|
|
123
|
+
default: () => never[];
|
|
124
|
+
}
|
|
125
|
+
>;
|
|
126
|
+
created: Schema.optionalWith<
|
|
127
|
+
typeof Schema.String,
|
|
128
|
+
{
|
|
129
|
+
default: () => string;
|
|
130
|
+
}
|
|
131
|
+
>;
|
|
132
|
+
updated: Schema.optionalWith<
|
|
133
|
+
typeof Schema.String,
|
|
134
|
+
{
|
|
135
|
+
default: () => string;
|
|
136
|
+
}
|
|
137
|
+
>;
|
|
138
|
+
urgency: Schema.optionalWith<
|
|
139
|
+
Schema.Literal<["low", "medium", "high", "urgent", "critical"]>,
|
|
140
|
+
{
|
|
141
|
+
default: () => "medium";
|
|
142
|
+
}
|
|
143
|
+
>;
|
|
144
|
+
energy: Schema.optionalWith<
|
|
145
|
+
Schema.Literal<["low", "medium", "high"]>,
|
|
146
|
+
{
|
|
147
|
+
default: () => "medium";
|
|
148
|
+
}
|
|
149
|
+
>;
|
|
150
|
+
due: Schema.optionalWith<
|
|
151
|
+
Schema.NullOr<typeof Schema.String>,
|
|
152
|
+
{
|
|
153
|
+
default: () => null;
|
|
154
|
+
}
|
|
155
|
+
>;
|
|
156
|
+
context: Schema.optionalWith<
|
|
157
|
+
typeof Schema.String,
|
|
158
|
+
{
|
|
159
|
+
default: () => string;
|
|
160
|
+
}
|
|
161
|
+
>;
|
|
162
|
+
subtasks: Schema.optionalWith<
|
|
163
|
+
Schema.Array$<
|
|
164
|
+
Schema.Struct<{
|
|
165
|
+
text: typeof Schema.String;
|
|
166
|
+
done: typeof Schema.Boolean;
|
|
167
|
+
}>
|
|
168
|
+
>,
|
|
169
|
+
{
|
|
170
|
+
default: () => never[];
|
|
171
|
+
}
|
|
172
|
+
>;
|
|
173
|
+
blocked_by: Schema.optionalWith<
|
|
174
|
+
Schema.Array$<typeof Schema.String>,
|
|
175
|
+
{
|
|
176
|
+
default: () => never[];
|
|
177
|
+
}
|
|
178
|
+
>;
|
|
179
|
+
estimated_minutes: Schema.optionalWith<
|
|
180
|
+
Schema.NullOr<typeof Schema.Number>,
|
|
181
|
+
{
|
|
182
|
+
default: () => null;
|
|
183
|
+
}
|
|
184
|
+
>;
|
|
185
|
+
actual_minutes: Schema.optionalWith<
|
|
186
|
+
Schema.NullOr<typeof Schema.Number>,
|
|
187
|
+
{
|
|
188
|
+
default: () => null;
|
|
189
|
+
}
|
|
190
|
+
>;
|
|
191
|
+
completed_at: Schema.optionalWith<
|
|
192
|
+
Schema.NullOr<typeof Schema.String>,
|
|
193
|
+
{
|
|
194
|
+
default: () => null;
|
|
195
|
+
}
|
|
196
|
+
>;
|
|
197
|
+
last_surfaced: Schema.optionalWith<
|
|
198
|
+
Schema.NullOr<typeof Schema.String>,
|
|
199
|
+
{
|
|
200
|
+
default: () => null;
|
|
201
|
+
}
|
|
202
|
+
>;
|
|
203
|
+
defer_until: Schema.optionalWith<
|
|
204
|
+
Schema.NullOr<typeof Schema.String>,
|
|
205
|
+
{
|
|
206
|
+
default: () => null;
|
|
207
|
+
}
|
|
208
|
+
>;
|
|
209
|
+
nudge_count: Schema.optionalWith<
|
|
210
|
+
typeof Schema.Number,
|
|
211
|
+
{
|
|
212
|
+
default: () => number;
|
|
213
|
+
}
|
|
214
|
+
>;
|
|
215
|
+
recurrence: Schema.optionalWith<
|
|
216
|
+
Schema.NullOr<typeof Schema.String>,
|
|
217
|
+
{
|
|
218
|
+
default: () => null;
|
|
219
|
+
}
|
|
220
|
+
>;
|
|
221
|
+
recurrence_trigger: Schema.optionalWith<
|
|
222
|
+
Schema.Literal<["clock", "completion"]>,
|
|
223
|
+
{
|
|
224
|
+
default: () => "clock";
|
|
225
|
+
}
|
|
226
|
+
>;
|
|
227
|
+
recurrence_strategy: Schema.optionalWith<
|
|
228
|
+
Schema.Literal<["replace", "accumulate"]>,
|
|
229
|
+
{
|
|
230
|
+
default: () => "replace";
|
|
231
|
+
}
|
|
232
|
+
>;
|
|
233
|
+
recurrence_last_generated: Schema.optionalWith<
|
|
234
|
+
Schema.NullOr<typeof Schema.String>,
|
|
235
|
+
{
|
|
236
|
+
default: () => null;
|
|
237
|
+
}
|
|
238
|
+
>;
|
|
239
|
+
}>;
|
|
240
|
+
export type TaskCreateInput = Schema.Schema.Encoded<typeof TaskCreateInput>;
|
|
241
|
+
export declare const TaskPatch: Schema.Struct<{
|
|
242
|
+
id: Schema.optionalWith<
|
|
243
|
+
typeof Schema.String,
|
|
244
|
+
{
|
|
245
|
+
exact: true;
|
|
246
|
+
}
|
|
247
|
+
>;
|
|
248
|
+
title: Schema.optionalWith<
|
|
249
|
+
typeof Schema.String,
|
|
250
|
+
{
|
|
251
|
+
exact: true;
|
|
252
|
+
}
|
|
253
|
+
>;
|
|
254
|
+
status: Schema.optionalWith<
|
|
255
|
+
Schema.Literal<
|
|
256
|
+
["active", "backlog", "blocked", "done", "dropped", "on-hold"]
|
|
257
|
+
>,
|
|
258
|
+
{
|
|
259
|
+
exact: true;
|
|
260
|
+
}
|
|
261
|
+
>;
|
|
262
|
+
area: Schema.optionalWith<
|
|
263
|
+
Schema.Literal<
|
|
264
|
+
[
|
|
265
|
+
"health",
|
|
266
|
+
"infrastructure",
|
|
267
|
+
"work",
|
|
268
|
+
"personal",
|
|
269
|
+
"blog",
|
|
270
|
+
"code",
|
|
271
|
+
"home",
|
|
272
|
+
"side-projects",
|
|
273
|
+
]
|
|
274
|
+
>,
|
|
275
|
+
{
|
|
276
|
+
exact: true;
|
|
277
|
+
}
|
|
278
|
+
>;
|
|
279
|
+
project: Schema.optionalWith<
|
|
280
|
+
Schema.NullOr<typeof Schema.String>,
|
|
281
|
+
{
|
|
282
|
+
exact: true;
|
|
283
|
+
}
|
|
284
|
+
>;
|
|
285
|
+
tags: Schema.optionalWith<
|
|
286
|
+
Schema.Array$<typeof Schema.String>,
|
|
287
|
+
{
|
|
288
|
+
exact: true;
|
|
289
|
+
}
|
|
290
|
+
>;
|
|
291
|
+
created: Schema.optionalWith<
|
|
292
|
+
typeof Schema.String,
|
|
293
|
+
{
|
|
294
|
+
exact: true;
|
|
295
|
+
}
|
|
296
|
+
>;
|
|
297
|
+
updated: Schema.optionalWith<
|
|
298
|
+
typeof Schema.String,
|
|
299
|
+
{
|
|
300
|
+
exact: true;
|
|
301
|
+
}
|
|
302
|
+
>;
|
|
303
|
+
urgency: Schema.optionalWith<
|
|
304
|
+
Schema.Literal<["low", "medium", "high", "urgent", "critical"]>,
|
|
305
|
+
{
|
|
306
|
+
exact: true;
|
|
307
|
+
}
|
|
308
|
+
>;
|
|
309
|
+
energy: Schema.optionalWith<
|
|
310
|
+
Schema.Literal<["low", "medium", "high"]>,
|
|
311
|
+
{
|
|
312
|
+
exact: true;
|
|
313
|
+
}
|
|
314
|
+
>;
|
|
315
|
+
due: Schema.optionalWith<
|
|
316
|
+
Schema.NullOr<typeof Schema.String>,
|
|
317
|
+
{
|
|
318
|
+
exact: true;
|
|
319
|
+
}
|
|
320
|
+
>;
|
|
321
|
+
context: Schema.optionalWith<
|
|
322
|
+
typeof Schema.String,
|
|
323
|
+
{
|
|
324
|
+
exact: true;
|
|
325
|
+
}
|
|
326
|
+
>;
|
|
327
|
+
subtasks: Schema.optionalWith<
|
|
328
|
+
Schema.Array$<
|
|
329
|
+
Schema.Struct<{
|
|
330
|
+
text: typeof Schema.String;
|
|
331
|
+
done: typeof Schema.Boolean;
|
|
332
|
+
}>
|
|
333
|
+
>,
|
|
334
|
+
{
|
|
335
|
+
exact: true;
|
|
336
|
+
}
|
|
337
|
+
>;
|
|
338
|
+
blocked_by: Schema.optionalWith<
|
|
339
|
+
Schema.Array$<typeof Schema.String>,
|
|
340
|
+
{
|
|
341
|
+
exact: true;
|
|
342
|
+
}
|
|
343
|
+
>;
|
|
344
|
+
estimated_minutes: Schema.optionalWith<
|
|
345
|
+
Schema.NullOr<typeof Schema.Number>,
|
|
346
|
+
{
|
|
347
|
+
exact: true;
|
|
348
|
+
}
|
|
349
|
+
>;
|
|
350
|
+
actual_minutes: Schema.optionalWith<
|
|
351
|
+
Schema.NullOr<typeof Schema.Number>,
|
|
352
|
+
{
|
|
353
|
+
exact: true;
|
|
354
|
+
}
|
|
355
|
+
>;
|
|
356
|
+
completed_at: Schema.optionalWith<
|
|
357
|
+
Schema.NullOr<typeof Schema.String>,
|
|
358
|
+
{
|
|
359
|
+
exact: true;
|
|
360
|
+
}
|
|
361
|
+
>;
|
|
362
|
+
last_surfaced: Schema.optionalWith<
|
|
363
|
+
Schema.NullOr<typeof Schema.String>,
|
|
364
|
+
{
|
|
365
|
+
exact: true;
|
|
366
|
+
}
|
|
367
|
+
>;
|
|
368
|
+
defer_until: Schema.optionalWith<
|
|
369
|
+
Schema.NullOr<typeof Schema.String>,
|
|
370
|
+
{
|
|
371
|
+
exact: true;
|
|
372
|
+
}
|
|
373
|
+
>;
|
|
374
|
+
nudge_count: Schema.optionalWith<
|
|
375
|
+
typeof Schema.Number,
|
|
376
|
+
{
|
|
377
|
+
exact: true;
|
|
378
|
+
}
|
|
379
|
+
>;
|
|
380
|
+
recurrence: Schema.optionalWith<
|
|
381
|
+
Schema.NullOr<typeof Schema.String>,
|
|
382
|
+
{
|
|
383
|
+
exact: true;
|
|
384
|
+
}
|
|
385
|
+
>;
|
|
386
|
+
recurrence_trigger: Schema.optionalWith<
|
|
387
|
+
Schema.Literal<["clock", "completion"]>,
|
|
388
|
+
{
|
|
389
|
+
exact: true;
|
|
390
|
+
}
|
|
391
|
+
>;
|
|
392
|
+
recurrence_strategy: Schema.optionalWith<
|
|
393
|
+
Schema.Literal<["replace", "accumulate"]>,
|
|
394
|
+
{
|
|
395
|
+
exact: true;
|
|
396
|
+
}
|
|
397
|
+
>;
|
|
398
|
+
recurrence_last_generated: Schema.optionalWith<
|
|
399
|
+
Schema.NullOr<typeof Schema.String>,
|
|
400
|
+
{
|
|
401
|
+
exact: true;
|
|
402
|
+
}
|
|
403
|
+
>;
|
|
404
|
+
}>;
|
|
405
|
+
export type TaskPatch = Schema.Schema.Encoded<typeof TaskPatch>;
|
|
406
|
+
export declare const WorkLogEntry: Schema.Struct<{
|
|
407
|
+
id: typeof Schema.String;
|
|
408
|
+
task_id: typeof Schema.String;
|
|
409
|
+
started_at: typeof Schema.String;
|
|
410
|
+
ended_at: Schema.NullOr<typeof Schema.String>;
|
|
411
|
+
date: typeof Schema.String;
|
|
412
|
+
}>;
|
|
413
|
+
export type WorkLogEntry = Schema.Schema.Type<typeof WorkLogEntry>;
|
|
414
|
+
export declare const WorkLogCreateInput: Schema.Struct<{
|
|
415
|
+
task_id: typeof Schema.String;
|
|
416
|
+
started_at: typeof Schema.String;
|
|
417
|
+
ended_at: Schema.optionalWith<
|
|
418
|
+
Schema.NullOr<typeof Schema.String>,
|
|
419
|
+
{
|
|
420
|
+
default: () => null;
|
|
421
|
+
}
|
|
422
|
+
>;
|
|
423
|
+
}>;
|
|
424
|
+
export type WorkLogCreateInput = Schema.Schema.Encoded<
|
|
425
|
+
typeof WorkLogCreateInput
|
|
426
|
+
>;
|
|
427
|
+
export declare const WorkLogPatch: Schema.Struct<{
|
|
428
|
+
id: Schema.optionalWith<
|
|
429
|
+
typeof Schema.String,
|
|
430
|
+
{
|
|
431
|
+
exact: true;
|
|
432
|
+
}
|
|
433
|
+
>;
|
|
434
|
+
task_id: Schema.optionalWith<
|
|
435
|
+
typeof Schema.String,
|
|
436
|
+
{
|
|
437
|
+
exact: true;
|
|
438
|
+
}
|
|
439
|
+
>;
|
|
440
|
+
started_at: Schema.optionalWith<
|
|
441
|
+
typeof Schema.String,
|
|
442
|
+
{
|
|
443
|
+
exact: true;
|
|
444
|
+
}
|
|
445
|
+
>;
|
|
446
|
+
ended_at: Schema.optionalWith<
|
|
447
|
+
Schema.NullOr<typeof Schema.String>,
|
|
448
|
+
{
|
|
449
|
+
exact: true;
|
|
450
|
+
}
|
|
451
|
+
>;
|
|
452
|
+
date: Schema.optionalWith<
|
|
453
|
+
typeof Schema.String,
|
|
454
|
+
{
|
|
455
|
+
exact: true;
|
|
456
|
+
}
|
|
457
|
+
>;
|
|
458
|
+
}>;
|
|
459
|
+
export type WorkLogPatch = Schema.Schema.Encoded<typeof WorkLogPatch>;
|
|
460
|
+
//# sourceMappingURL=schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,eAAO,MAAM,UAAU,gFAOtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,QAAQ,2GASpB,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE3D,eAAO,MAAM,WAAW,iEAMvB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjE,eAAO,MAAM,UAAU,2CAA0C,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,OAAO;;;EAGlB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAC;AAEzD,eAAO,MAAM,qBAAqB,yCAAwC,CAAC;AAC3E,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACrD,OAAO,qBAAqB,CAC5B,CAAC;AAEF,eAAO,MAAM,sBAAsB,2CAA0C,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACtD,OAAO,sBAAsB,CAC7B,CAAC;AAEF,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;uBAhFD,MAAM;;;uBAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4I/B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC,CAAC;AAEhE,eAAO,MAAM,YAAY;;;;;;EAMvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnE,eAAO,MAAM,kBAAkB;;;;;;EAM7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CACrD,OAAO,kBAAkB,CACzB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAQvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,YAAY,CAAC,CAAC"}
|
|
@@ -0,0 +1,166 @@
|
|
|
1
|
+
import * as Schema from "effect/Schema";
|
|
2
|
+
const currentDateIso = () => new Date().toISOString().slice(0, 10);
|
|
3
|
+
export const TaskStatus = Schema.Literal("active", "backlog", "blocked", "done", "dropped", "on-hold");
|
|
4
|
+
export const TaskArea = Schema.Literal("health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects");
|
|
5
|
+
export const TaskUrgency = Schema.Literal("low", "medium", "high", "urgent", "critical");
|
|
6
|
+
export const TaskEnergy = Schema.Literal("low", "medium", "high");
|
|
7
|
+
export const Subtask = Schema.Struct({
|
|
8
|
+
text: Schema.String,
|
|
9
|
+
done: Schema.Boolean,
|
|
10
|
+
});
|
|
11
|
+
export const TaskRecurrenceTrigger = Schema.Literal("clock", "completion");
|
|
12
|
+
export const TaskRecurrenceStrategy = Schema.Literal("replace", "accumulate");
|
|
13
|
+
export const Task = Schema.Struct({
|
|
14
|
+
id: Schema.String,
|
|
15
|
+
title: Schema.String,
|
|
16
|
+
status: TaskStatus,
|
|
17
|
+
area: TaskArea,
|
|
18
|
+
project: Schema.NullOr(Schema.String),
|
|
19
|
+
tags: Schema.Array(Schema.String),
|
|
20
|
+
created: Schema.String,
|
|
21
|
+
updated: Schema.String,
|
|
22
|
+
urgency: TaskUrgency,
|
|
23
|
+
energy: TaskEnergy,
|
|
24
|
+
due: Schema.NullOr(Schema.String),
|
|
25
|
+
context: Schema.String,
|
|
26
|
+
subtasks: Schema.Array(Subtask),
|
|
27
|
+
blocked_by: Schema.Array(Schema.String),
|
|
28
|
+
estimated_minutes: Schema.NullOr(Schema.Number),
|
|
29
|
+
actual_minutes: Schema.NullOr(Schema.Number),
|
|
30
|
+
completed_at: Schema.NullOr(Schema.String),
|
|
31
|
+
last_surfaced: Schema.NullOr(Schema.String),
|
|
32
|
+
defer_until: Schema.NullOr(Schema.String),
|
|
33
|
+
nudge_count: Schema.Number,
|
|
34
|
+
recurrence: Schema.NullOr(Schema.String),
|
|
35
|
+
recurrence_trigger: TaskRecurrenceTrigger,
|
|
36
|
+
recurrence_strategy: TaskRecurrenceStrategy,
|
|
37
|
+
recurrence_last_generated: Schema.NullOr(Schema.String),
|
|
38
|
+
});
|
|
39
|
+
export const TaskCreateInput = Schema.Struct({
|
|
40
|
+
title: Schema.String,
|
|
41
|
+
status: Schema.optionalWith(TaskStatus, { default: () => "active" }),
|
|
42
|
+
area: Schema.optionalWith(TaskArea, { default: () => "personal" }),
|
|
43
|
+
project: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
44
|
+
default: () => null,
|
|
45
|
+
}),
|
|
46
|
+
tags: Schema.optionalWith(Schema.Array(Schema.String), {
|
|
47
|
+
default: () => [],
|
|
48
|
+
}),
|
|
49
|
+
created: Schema.optionalWith(Schema.String, {
|
|
50
|
+
default: currentDateIso,
|
|
51
|
+
}),
|
|
52
|
+
updated: Schema.optionalWith(Schema.String, {
|
|
53
|
+
default: currentDateIso,
|
|
54
|
+
}),
|
|
55
|
+
urgency: Schema.optionalWith(TaskUrgency, { default: () => "medium" }),
|
|
56
|
+
energy: Schema.optionalWith(TaskEnergy, { default: () => "medium" }),
|
|
57
|
+
due: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
58
|
+
default: () => null,
|
|
59
|
+
}),
|
|
60
|
+
context: Schema.optionalWith(Schema.String, {
|
|
61
|
+
default: () => "",
|
|
62
|
+
}),
|
|
63
|
+
subtasks: Schema.optionalWith(Schema.Array(Subtask), {
|
|
64
|
+
default: () => [],
|
|
65
|
+
}),
|
|
66
|
+
blocked_by: Schema.optionalWith(Schema.Array(Schema.String), {
|
|
67
|
+
default: () => [],
|
|
68
|
+
}),
|
|
69
|
+
estimated_minutes: Schema.optionalWith(Schema.NullOr(Schema.Number), {
|
|
70
|
+
default: () => null,
|
|
71
|
+
}),
|
|
72
|
+
actual_minutes: Schema.optionalWith(Schema.NullOr(Schema.Number), {
|
|
73
|
+
default: () => null,
|
|
74
|
+
}),
|
|
75
|
+
completed_at: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
76
|
+
default: () => null,
|
|
77
|
+
}),
|
|
78
|
+
last_surfaced: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
79
|
+
default: () => null,
|
|
80
|
+
}),
|
|
81
|
+
defer_until: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
82
|
+
default: () => null,
|
|
83
|
+
}),
|
|
84
|
+
nudge_count: Schema.optionalWith(Schema.Number, {
|
|
85
|
+
default: () => 0,
|
|
86
|
+
}),
|
|
87
|
+
recurrence: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
88
|
+
default: () => null,
|
|
89
|
+
}),
|
|
90
|
+
recurrence_trigger: Schema.optionalWith(TaskRecurrenceTrigger, {
|
|
91
|
+
default: () => "clock",
|
|
92
|
+
}),
|
|
93
|
+
recurrence_strategy: Schema.optionalWith(TaskRecurrenceStrategy, {
|
|
94
|
+
default: () => "replace",
|
|
95
|
+
}),
|
|
96
|
+
recurrence_last_generated: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
97
|
+
default: () => null,
|
|
98
|
+
}),
|
|
99
|
+
});
|
|
100
|
+
export const TaskPatch = Schema.Struct({
|
|
101
|
+
id: Schema.optionalWith(Schema.String, { exact: true }),
|
|
102
|
+
title: Schema.optionalWith(Schema.String, { exact: true }),
|
|
103
|
+
status: Schema.optionalWith(TaskStatus, { exact: true }),
|
|
104
|
+
area: Schema.optionalWith(TaskArea, { exact: true }),
|
|
105
|
+
project: Schema.optionalWith(Schema.NullOr(Schema.String), { exact: true }),
|
|
106
|
+
tags: Schema.optionalWith(Schema.Array(Schema.String), { exact: true }),
|
|
107
|
+
created: Schema.optionalWith(Schema.String, { exact: true }),
|
|
108
|
+
updated: Schema.optionalWith(Schema.String, { exact: true }),
|
|
109
|
+
urgency: Schema.optionalWith(TaskUrgency, { exact: true }),
|
|
110
|
+
energy: Schema.optionalWith(TaskEnergy, { exact: true }),
|
|
111
|
+
due: Schema.optionalWith(Schema.NullOr(Schema.String), { exact: true }),
|
|
112
|
+
context: Schema.optionalWith(Schema.String, { exact: true }),
|
|
113
|
+
subtasks: Schema.optionalWith(Schema.Array(Subtask), { exact: true }),
|
|
114
|
+
blocked_by: Schema.optionalWith(Schema.Array(Schema.String), { exact: true }),
|
|
115
|
+
estimated_minutes: Schema.optionalWith(Schema.NullOr(Schema.Number), {
|
|
116
|
+
exact: true,
|
|
117
|
+
}),
|
|
118
|
+
actual_minutes: Schema.optionalWith(Schema.NullOr(Schema.Number), {
|
|
119
|
+
exact: true,
|
|
120
|
+
}),
|
|
121
|
+
completed_at: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
122
|
+
exact: true,
|
|
123
|
+
}),
|
|
124
|
+
last_surfaced: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
125
|
+
exact: true,
|
|
126
|
+
}),
|
|
127
|
+
defer_until: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
128
|
+
exact: true,
|
|
129
|
+
}),
|
|
130
|
+
nudge_count: Schema.optionalWith(Schema.Number, { exact: true }),
|
|
131
|
+
recurrence: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
132
|
+
exact: true,
|
|
133
|
+
}),
|
|
134
|
+
recurrence_trigger: Schema.optionalWith(TaskRecurrenceTrigger, {
|
|
135
|
+
exact: true,
|
|
136
|
+
}),
|
|
137
|
+
recurrence_strategy: Schema.optionalWith(TaskRecurrenceStrategy, {
|
|
138
|
+
exact: true,
|
|
139
|
+
}),
|
|
140
|
+
recurrence_last_generated: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
141
|
+
exact: true,
|
|
142
|
+
}),
|
|
143
|
+
});
|
|
144
|
+
export const WorkLogEntry = Schema.Struct({
|
|
145
|
+
id: Schema.String,
|
|
146
|
+
task_id: Schema.String,
|
|
147
|
+
started_at: Schema.String,
|
|
148
|
+
ended_at: Schema.NullOr(Schema.String),
|
|
149
|
+
date: Schema.String,
|
|
150
|
+
});
|
|
151
|
+
export const WorkLogCreateInput = Schema.Struct({
|
|
152
|
+
task_id: Schema.String,
|
|
153
|
+
started_at: Schema.String,
|
|
154
|
+
ended_at: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
155
|
+
default: () => null,
|
|
156
|
+
}),
|
|
157
|
+
});
|
|
158
|
+
export const WorkLogPatch = Schema.Struct({
|
|
159
|
+
id: Schema.optionalWith(Schema.String, { exact: true }),
|
|
160
|
+
task_id: Schema.optionalWith(Schema.String, { exact: true }),
|
|
161
|
+
started_at: Schema.optionalWith(Schema.String, { exact: true }),
|
|
162
|
+
ended_at: Schema.optionalWith(Schema.NullOr(Schema.String), {
|
|
163
|
+
exact: true,
|
|
164
|
+
}),
|
|
165
|
+
date: Schema.optionalWith(Schema.String, { exact: true }),
|
|
166
|
+
});
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../src/schema.test.ts"],"names":[],"mappings":""}
|