nandi.uk
This repository has no description
initial implementation of sync subdomain and basic usecase that handles domain event
author
Wesley Finck
date
(Jan 30, 2026, 12:31 PM -0800)
commit
8ef0e31f
8ef0e31f17fe7a6478b3b6507c63880f9cfba3b1
parent
910f1791
910f179118a7e169a7d26b001a264c6c4d527aa6
+2048
-1
+15
.agent/logs/202601229_domain_event_handling_guide.md
+15
.agent/logs/202601229_domain_event_handling_guide.md
···
325
325
7. `src/shared/infrastructure/http/factories/UseCaseFactory.ts` — Pass eventPublisher
326
326
8. `src/modules/<module>/application/eventHandlers/...Handler.ts` — Create handler
327
327
9. `src/shared/infrastructure/processes/<Worker>Process.ts` — Register handler
328
+
329
+
## Build steps:
330
+
331
+
make sure to update `tsup.config.ts`:
332
+
which has the `entry` field:
333
+
334
+
```ts
335
+
entry: {
336
+
index: 'src/index.ts',
337
+
'workers/feed-worker': 'src/workers/feed-worker.ts',
338
+
'workers/search-worker': 'src/workers/search-worker.ts',
339
+
'workers/firehose-worker': 'src/workers/firehose-worker.ts',
340
+
'workers/notification-worker': 'src/workers/notification-worker.ts',
341
+
},
342
+
```
+7
fly.development.toml
+7
fly.development.toml
···
9
9
search-worker = "npm run worker:search"
10
10
firehose-worker = "npm run worker:firehose"
11
11
notification-worker = "npm run worker:notifications"
12
+
sync-worker = "npm run worker:sync"
12
13
13
14
[http_service]
14
15
internal_port = 3000
···
46
47
[[vm]]
47
48
processes = ['notification-worker']
48
49
memory = '256mb'
50
+
cpu_kind = 'shared'
51
+
cpus = 1
52
+
53
+
[[vm]]
54
+
processes = ['sync-worker']
55
+
memory = '512mb'
49
56
cpu_kind = 'shared'
50
57
cpus = 1
51
58
+7
fly.production.toml
+7
fly.production.toml
···
9
9
search-worker = "npm run worker:search"
10
10
firehose-worker = "npm run worker:firehose"
11
11
notification-worker = "npm run worker:notifications"
12
+
sync-worker = "npm run worker:sync"
12
13
13
14
[http_service]
14
15
internal_port = 3000
···
47
48
[[vm]]
48
49
processes = ['notification-worker']
49
50
memory = '512mb'
51
+
cpu_kind = 'shared'
52
+
cpus = 1
53
+
54
+
[[vm]]
55
+
processes = ['sync-worker']
56
+
memory = '1gb'
50
57
cpu_kind = 'shared'
51
58
cpus = 1
52
59
+1
package.json
+1
package.json
···
21
21
"worker:search": "node dist/workers/search-worker.js",
22
22
"worker:firehose": "node dist/workers/firehose-worker.js",
23
23
"worker:notifications": "node dist/workers/notification-worker.js",
24
+
"worker:sync": "node dist/workers/sync-worker.js",
24
25
"test": "jest",
25
26
"test:unit": "jest --testPathIgnorePatterns='.integration.test.' --testPathIgnorePatterns='.e2e.test.'",
26
27
"test:integration": "jest --testPathPattern='.integration.test.'",
+13
src/modules/cards/tests/test-utils/createTestSchema.ts
+13
src/modules/cards/tests/test-utils/createTestSchema.ts
···
96
96
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
97
97
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
98
98
)`,
99
+
100
+
// Sync statuses table (no dependencies)
101
+
sql`CREATE TABLE IF NOT EXISTS sync_statuses (
102
+
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
103
+
curator_id TEXT NOT NULL UNIQUE,
104
+
sync_state TEXT NOT NULL,
105
+
last_synced_at TIMESTAMP WITH TIME ZONE,
106
+
last_sync_attempt_at TIMESTAMP WITH TIME ZONE,
107
+
sync_error_message TEXT,
108
+
records_processed INTEGER,
109
+
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
110
+
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
111
+
)`,
99
112
];
100
113
101
114
// Execute table creation queries in order
+22
src/modules/sync/application/eventHandlers/CardAddedToLibraryEventHandler.ts
+22
src/modules/sync/application/eventHandlers/CardAddedToLibraryEventHandler.ts
···
1
+
import { CardAddedToLibraryEvent } from '../../../cards/domain/events/CardAddedToLibraryEvent';
2
+
import { IEventHandler } from '../../../../shared/application/events/IEventSubscriber';
3
+
import { Result } from '../../../../shared/core/Result';
4
+
import { SyncAccountDataUseCase } from '../useCases/SyncAccountDataUseCase';
5
+
6
+
export class CardAddedToLibraryEventHandler
7
+
implements IEventHandler<CardAddedToLibraryEvent>
8
+
{
9
+
constructor(private syncAccountDataUseCase: SyncAccountDataUseCase) {}
10
+
11
+
async handle(event: CardAddedToLibraryEvent): Promise<Result<void>> {
12
+
console.log(
13
+
`[SYNC] Handling CardAddedToLibraryEvent for curator: ${event.curatorId.value}`,
14
+
);
15
+
16
+
// Pass the curator ID from the event to the sync use case
17
+
return this.syncAccountDataUseCase.execute({
18
+
curatorId: event.curatorId.value,
19
+
cardId: event.cardId.getStringValue(),
20
+
});
21
+
}
22
+
}
+141
src/modules/sync/application/useCases/SyncAccountDataUseCase.ts
+141
src/modules/sync/application/useCases/SyncAccountDataUseCase.ts
···
1
+
import { Result, ok, err } from '../../../../shared/core/Result';
2
+
import { UseCase } from '../../../../shared/core/UseCase';
3
+
import { UseCaseError } from '../../../../shared/core/UseCaseError';
4
+
import { AppError } from '../../../../shared/core/AppError';
5
+
import { ISyncStatusRepository } from '../../domain/repositories/ISyncStatusRepository';
6
+
import { DID } from '../../../user/domain/value-objects/DID';
7
+
import { SyncStatus } from '../../domain/SyncStatus';
8
+
9
+
export interface SyncAccountDataDTO {
10
+
curatorId: string;
11
+
cardId: string;
12
+
}
13
+
14
+
export class ValidationError extends UseCaseError {
15
+
constructor(message: string) {
16
+
super(message);
17
+
}
18
+
}
19
+
20
+
export class SyncAccountDataUseCase
21
+
implements
22
+
UseCase<
23
+
SyncAccountDataDTO,
24
+
Result<void, ValidationError | AppError.UnexpectedError>
25
+
>
26
+
{
27
+
constructor(private syncStatusRepo: ISyncStatusRepository) {}
28
+
29
+
async execute(
30
+
request: SyncAccountDataDTO,
31
+
): Promise<Result<void, ValidationError | AppError.UnexpectedError>> {
32
+
try {
33
+
console.log(
34
+
`[SYNC] SyncAccountDataUseCase triggered for curator: ${request.curatorId}, card: ${request.cardId}`,
35
+
);
36
+
37
+
// Create DID value object
38
+
const didResult = DID.create(request.curatorId);
39
+
if (didResult.isErr()) {
40
+
return err(new ValidationError(didResult.error.message));
41
+
}
42
+
const curatorId = didResult.value;
43
+
44
+
// Check if user has already been synced
45
+
const syncStatusResult =
46
+
await this.syncStatusRepo.findByCuratorId(curatorId);
47
+
if (syncStatusResult.isErr()) {
48
+
console.error(
49
+
'[SYNC] Error fetching sync status:',
50
+
syncStatusResult.error,
51
+
);
52
+
return err(AppError.UnexpectedError.create(syncStatusResult.error));
53
+
}
54
+
55
+
const existingSyncStatus = syncStatusResult.value;
56
+
57
+
if (existingSyncStatus && existingSyncStatus.syncState.isCompleted()) {
58
+
console.log(
59
+
`[SYNC] User ${request.curatorId} has already been synced, skipping`,
60
+
);
61
+
return ok(undefined);
62
+
}
63
+
64
+
// Create or update sync status to mark in progress
65
+
let syncStatus: SyncStatus;
66
+
if (existingSyncStatus) {
67
+
syncStatus = existingSyncStatus;
68
+
syncStatus.markSyncInProgress();
69
+
} else {
70
+
const newSyncStatusResult = SyncStatus.createNew(curatorId);
71
+
if (newSyncStatusResult.isErr()) {
72
+
return err(
73
+
AppError.UnexpectedError.create(newSyncStatusResult.error),
74
+
);
75
+
}
76
+
syncStatus = newSyncStatusResult.value;
77
+
syncStatus.markSyncInProgress();
78
+
}
79
+
80
+
// Save sync status
81
+
const saveResult = await this.syncStatusRepo.save(syncStatus);
82
+
if (saveResult.isErr()) {
83
+
console.error('[SYNC] Error saving sync status:', saveResult.error);
84
+
return err(AppError.UnexpectedError.create(saveResult.error));
85
+
}
86
+
87
+
console.log(
88
+
`[SYNC] Starting sync process for user ${request.curatorId}...`,
89
+
);
90
+
91
+
// TODO: Trigger the actual sync process
92
+
// This would involve:
93
+
// 1. Getting an authenticated agent for the user
94
+
// 2. Fetching records from their ATProto repository
95
+
// 3. Transforming records into cards/collections
96
+
// 4. Saving them to the database
97
+
const recordsProcessed = await this.performSync(request.curatorId);
98
+
99
+
// Mark sync as completed
100
+
syncStatus.markSyncCompleted(recordsProcessed);
101
+
const finalSaveResult = await this.syncStatusRepo.save(syncStatus);
102
+
if (finalSaveResult.isErr()) {
103
+
console.error(
104
+
'[SYNC] Error saving final sync status:',
105
+
finalSaveResult.error,
106
+
);
107
+
// Don't fail the whole operation if we can't save the status
108
+
}
109
+
110
+
console.log(
111
+
`[SYNC] Sync process completed for user ${request.curatorId}`,
112
+
);
113
+
114
+
return ok(undefined);
115
+
} catch (error) {
116
+
console.error('[SYNC] Error in SyncAccountDataUseCase:', error);
117
+
return err(AppError.UnexpectedError.create(error));
118
+
}
119
+
}
120
+
121
+
/**
122
+
* Perform the actual sync process for a user
123
+
* TODO: Implement actual sync logic
124
+
*/
125
+
private async performSync(curatorId: string): Promise<number> {
126
+
// Stub implementation
127
+
console.log(`[SYNC] Performing sync for user ${curatorId} (stub)`);
128
+
129
+
// Future implementation would:
130
+
// 1. Get authenticated agent
131
+
// 2. Call agent.com.atproto.repo.listRecords for each collection type
132
+
// 3. Transform and save records
133
+
// 4. Return count of records processed
134
+
135
+
// Simulate async operation
136
+
await new Promise((resolve) => setTimeout(resolve, 100));
137
+
138
+
// Return stub count
139
+
return 0;
140
+
}
141
+
}
+112
src/modules/sync/domain/SyncStatus.ts
+112
src/modules/sync/domain/SyncStatus.ts
···
1
+
import { AggregateRoot } from 'src/shared/domain/AggregateRoot';
2
+
import { UniqueEntityID } from 'src/shared/domain/UniqueEntityID';
3
+
import { Guard, IGuardArgument } from 'src/shared/core/Guard';
4
+
import { err, ok, Result } from 'src/shared/core/Result';
5
+
import { DID } from 'src/modules/user/domain/value-objects/DID';
6
+
import { SyncState } from './value-objects/SyncState';
7
+
8
+
export interface SyncStatusProps {
9
+
curatorId: DID;
10
+
syncState: SyncState;
11
+
lastSyncedAt?: Date;
12
+
lastSyncAttemptAt?: Date;
13
+
syncErrorMessage?: string;
14
+
recordsProcessed?: number;
15
+
createdAt: Date;
16
+
updatedAt: Date;
17
+
}
18
+
19
+
export class SyncStatus extends AggregateRoot<SyncStatusProps> {
20
+
get syncStatusId(): UniqueEntityID {
21
+
return this._id;
22
+
}
23
+
24
+
get curatorId(): DID {
25
+
return this.props.curatorId;
26
+
}
27
+
28
+
get syncState(): SyncState {
29
+
return this.props.syncState;
30
+
}
31
+
32
+
get lastSyncedAt(): Date | undefined {
33
+
return this.props.lastSyncedAt;
34
+
}
35
+
36
+
get lastSyncAttemptAt(): Date | undefined {
37
+
return this.props.lastSyncAttemptAt;
38
+
}
39
+
40
+
get syncErrorMessage(): string | undefined {
41
+
return this.props.syncErrorMessage;
42
+
}
43
+
44
+
get recordsProcessed(): number | undefined {
45
+
return this.props.recordsProcessed;
46
+
}
47
+
48
+
get createdAt(): Date {
49
+
return this.props.createdAt;
50
+
}
51
+
52
+
get updatedAt(): Date {
53
+
return this.props.updatedAt;
54
+
}
55
+
56
+
public markSyncInProgress(): void {
57
+
this.props.syncState = SyncState.inProgress();
58
+
this.props.lastSyncAttemptAt = new Date();
59
+
this.props.updatedAt = new Date();
60
+
}
61
+
62
+
public markSyncCompleted(recordsProcessed: number): void {
63
+
this.props.syncState = SyncState.completed();
64
+
this.props.lastSyncedAt = new Date();
65
+
this.props.recordsProcessed = recordsProcessed;
66
+
this.props.syncErrorMessage = undefined;
67
+
this.props.updatedAt = new Date();
68
+
}
69
+
70
+
public markSyncFailed(errorMessage: string): void {
71
+
this.props.syncState = SyncState.failed();
72
+
this.props.syncErrorMessage = errorMessage;
73
+
this.props.updatedAt = new Date();
74
+
}
75
+
76
+
private constructor(props: SyncStatusProps, id?: UniqueEntityID) {
77
+
super(props, id);
78
+
}
79
+
80
+
public static create(
81
+
props: SyncStatusProps,
82
+
id?: UniqueEntityID,
83
+
): Result<SyncStatus> {
84
+
const guardArgs: IGuardArgument[] = [
85
+
{ argument: props.curatorId, argumentName: 'curatorId' },
86
+
{ argument: props.syncState, argumentName: 'syncState' },
87
+
{ argument: props.createdAt, argumentName: 'createdAt' },
88
+
{ argument: props.updatedAt, argumentName: 'updatedAt' },
89
+
];
90
+
91
+
const guardResult = Guard.againstNullOrUndefinedBulk(guardArgs);
92
+
93
+
if (guardResult.isErr()) {
94
+
return err(new Error(guardResult.error));
95
+
}
96
+
97
+
const syncStatus = new SyncStatus(props, id);
98
+
99
+
return ok(syncStatus);
100
+
}
101
+
102
+
public static createNew(curatorId: DID): Result<SyncStatus> {
103
+
const now = new Date();
104
+
105
+
return SyncStatus.create({
106
+
curatorId,
107
+
syncState: SyncState.notSynced(),
108
+
createdAt: now,
109
+
updatedAt: now,
110
+
});
111
+
}
112
+
}
+8
src/modules/sync/domain/repositories/ISyncStatusRepository.ts
+8
src/modules/sync/domain/repositories/ISyncStatusRepository.ts
···
1
+
import { Result } from 'src/shared/core/Result';
2
+
import { SyncStatus } from '../SyncStatus';
3
+
import { DID } from 'src/modules/user/domain/value-objects/DID';
4
+
5
+
export interface ISyncStatusRepository {
6
+
findByCuratorId(curatorId: DID): Promise<Result<SyncStatus | null>>;
7
+
save(syncStatus: SyncStatus): Promise<Result<void>>;
8
+
}
+64
src/modules/sync/domain/value-objects/SyncState.ts
+64
src/modules/sync/domain/value-objects/SyncState.ts
···
1
+
import { Result, ok, err } from 'src/shared/core/Result';
2
+
3
+
export enum SyncStateEnum {
4
+
NOT_SYNCED = 'NOT_SYNCED',
5
+
IN_PROGRESS = 'IN_PROGRESS',
6
+
COMPLETED = 'COMPLETED',
7
+
FAILED = 'FAILED',
8
+
}
9
+
10
+
export class SyncState {
11
+
private constructor(private readonly _value: SyncStateEnum) {}
12
+
13
+
get value(): SyncStateEnum {
14
+
return this._value;
15
+
}
16
+
17
+
public static create(state: string): Result<SyncState> {
18
+
const upperState = state.toUpperCase();
19
+
if (!Object.values(SyncStateEnum).includes(upperState as SyncStateEnum)) {
20
+
return err(
21
+
new Error(
22
+
`Invalid sync state: ${state}. Must be one of: ${Object.values(SyncStateEnum).join(', ')}`,
23
+
),
24
+
);
25
+
}
26
+
return ok(new SyncState(upperState as SyncStateEnum));
27
+
}
28
+
29
+
public static notSynced(): SyncState {
30
+
return new SyncState(SyncStateEnum.NOT_SYNCED);
31
+
}
32
+
33
+
public static inProgress(): SyncState {
34
+
return new SyncState(SyncStateEnum.IN_PROGRESS);
35
+
}
36
+
37
+
public static completed(): SyncState {
38
+
return new SyncState(SyncStateEnum.COMPLETED);
39
+
}
40
+
41
+
public static failed(): SyncState {
42
+
return new SyncState(SyncStateEnum.FAILED);
43
+
}
44
+
45
+
public isNotSynced(): boolean {
46
+
return this._value === SyncStateEnum.NOT_SYNCED;
47
+
}
48
+
49
+
public isInProgress(): boolean {
50
+
return this._value === SyncStateEnum.IN_PROGRESS;
51
+
}
52
+
53
+
public isCompleted(): boolean {
54
+
return this._value === SyncStateEnum.COMPLETED;
55
+
}
56
+
57
+
public isFailed(): boolean {
58
+
return this._value === SyncStateEnum.FAILED;
59
+
}
60
+
61
+
public equals(other: SyncState): boolean {
62
+
return this._value === other._value;
63
+
}
64
+
}
+95
src/modules/sync/infrastructure/repositories/DrizzleSyncStatusRepository.ts
+95
src/modules/sync/infrastructure/repositories/DrizzleSyncStatusRepository.ts
···
1
+
import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
2
+
import { eq } from 'drizzle-orm';
3
+
import { ISyncStatusRepository } from '../../domain/repositories/ISyncStatusRepository';
4
+
import { SyncStatus } from '../../domain/SyncStatus';
5
+
import { DID } from 'src/modules/user/domain/value-objects/DID';
6
+
import { SyncState } from '../../domain/value-objects/SyncState';
7
+
import { syncStatuses } from './schema/syncStatus.sql';
8
+
import { UniqueEntityID } from 'src/shared/domain/UniqueEntityID';
9
+
import { err, ok, Result } from 'src/shared/core/Result';
10
+
11
+
export class DrizzleSyncStatusRepository implements ISyncStatusRepository {
12
+
constructor(private db: PostgresJsDatabase) {}
13
+
14
+
async findByCuratorId(curatorId: DID): Promise<Result<SyncStatus | null>> {
15
+
try {
16
+
const result = await this.db
17
+
.select()
18
+
.from(syncStatuses)
19
+
.where(eq(syncStatuses.curatorId, curatorId.value))
20
+
.limit(1);
21
+
22
+
if (result.length === 0) {
23
+
return ok(null);
24
+
}
25
+
26
+
const data = result[0];
27
+
28
+
if (!data) {
29
+
return ok(null);
30
+
}
31
+
32
+
// Create sync state value object
33
+
const syncStateResult = SyncState.create(data.syncState);
34
+
if (syncStateResult.isErr()) {
35
+
return err(syncStateResult.error);
36
+
}
37
+
38
+
// Create sync status entity
39
+
const syncStatusResult = SyncStatus.create(
40
+
{
41
+
curatorId,
42
+
syncState: syncStateResult.value,
43
+
lastSyncedAt: data.lastSyncedAt ?? undefined,
44
+
lastSyncAttemptAt: data.lastSyncAttemptAt ?? undefined,
45
+
syncErrorMessage: data.syncErrorMessage ?? undefined,
46
+
recordsProcessed: data.recordsProcessed ?? undefined,
47
+
createdAt: data.createdAt,
48
+
updatedAt: data.updatedAt,
49
+
},
50
+
new UniqueEntityID(data.id),
51
+
);
52
+
53
+
if (syncStatusResult.isErr()) {
54
+
return err(syncStatusResult.error);
55
+
}
56
+
57
+
return ok(syncStatusResult.value);
58
+
} catch (error: any) {
59
+
return err(error);
60
+
}
61
+
}
62
+
63
+
async save(syncStatus: SyncStatus): Promise<Result<void>> {
64
+
try {
65
+
await this.db
66
+
.insert(syncStatuses)
67
+
.values({
68
+
id: syncStatus.syncStatusId.toString(),
69
+
curatorId: syncStatus.curatorId.value,
70
+
syncState: syncStatus.syncState.value,
71
+
lastSyncedAt: syncStatus.lastSyncedAt ?? null,
72
+
lastSyncAttemptAt: syncStatus.lastSyncAttemptAt ?? null,
73
+
syncErrorMessage: syncStatus.syncErrorMessage ?? null,
74
+
recordsProcessed: syncStatus.recordsProcessed ?? null,
75
+
createdAt: syncStatus.createdAt,
76
+
updatedAt: syncStatus.updatedAt,
77
+
})
78
+
.onConflictDoUpdate({
79
+
target: syncStatuses.curatorId,
80
+
set: {
81
+
syncState: syncStatus.syncState.value,
82
+
lastSyncedAt: syncStatus.lastSyncedAt ?? null,
83
+
lastSyncAttemptAt: syncStatus.lastSyncAttemptAt ?? null,
84
+
syncErrorMessage: syncStatus.syncErrorMessage ?? null,
85
+
recordsProcessed: syncStatus.recordsProcessed ?? null,
86
+
updatedAt: syncStatus.updatedAt,
87
+
},
88
+
});
89
+
90
+
return ok(undefined);
91
+
} catch (error: any) {
92
+
return err(error);
93
+
}
94
+
}
95
+
}
+13
src/modules/sync/infrastructure/repositories/schema/syncStatus.sql.ts
+13
src/modules/sync/infrastructure/repositories/schema/syncStatus.sql.ts
···
1
+
import { pgTable, text, timestamp, integer, uuid } from 'drizzle-orm/pg-core';
2
+
3
+
export const syncStatuses = pgTable('sync_statuses', {
4
+
id: uuid('id').primaryKey().defaultRandom(),
5
+
curatorId: text('curator_id').notNull().unique(),
6
+
syncState: text('sync_state').notNull(),
7
+
lastSyncedAt: timestamp('last_synced_at'),
8
+
lastSyncAttemptAt: timestamp('last_sync_attempt_at'),
9
+
syncErrorMessage: text('sync_error_message'),
10
+
recordsProcessed: integer('records_processed'),
11
+
createdAt: timestamp('created_at').notNull().defaultNow(),
12
+
updatedAt: timestamp('updated_at').notNull().defaultNow(),
13
+
});
+42
src/modules/sync/tests/infrastructure/InMemorySyncStatusRepository.ts
+42
src/modules/sync/tests/infrastructure/InMemorySyncStatusRepository.ts
···
1
+
import { Result, ok, err } from 'src/shared/core/Result';
2
+
import { SyncStatus } from '../../domain/SyncStatus';
3
+
import { ISyncStatusRepository } from '../../domain/repositories/ISyncStatusRepository';
4
+
import { DID } from 'src/modules/user/domain/value-objects/DID';
5
+
6
+
export class InMemorySyncStatusRepository implements ISyncStatusRepository {
7
+
private static instance: InMemorySyncStatusRepository;
8
+
private syncStatuses: Map<string, SyncStatus> = new Map();
9
+
10
+
private constructor() {}
11
+
12
+
public static getInstance(): InMemorySyncStatusRepository {
13
+
if (!InMemorySyncStatusRepository.instance) {
14
+
InMemorySyncStatusRepository.instance =
15
+
new InMemorySyncStatusRepository();
16
+
}
17
+
return InMemorySyncStatusRepository.instance;
18
+
}
19
+
20
+
async findByCuratorId(curatorId: DID): Promise<Result<SyncStatus | null>> {
21
+
try {
22
+
const syncStatus = this.syncStatuses.get(curatorId.value);
23
+
return ok(syncStatus || null);
24
+
} catch (error: any) {
25
+
return err(error);
26
+
}
27
+
}
28
+
29
+
async save(syncStatus: SyncStatus): Promise<Result<void>> {
30
+
try {
31
+
this.syncStatuses.set(syncStatus.curatorId.value, syncStatus);
32
+
return ok(undefined);
33
+
} catch (error: any) {
34
+
return err(error);
35
+
}
36
+
}
37
+
38
+
// Helper method for testing
39
+
clear(): void {
40
+
this.syncStatuses.clear();
41
+
}
42
+
}
+22
src/workers/sync-worker.ts
+22
src/workers/sync-worker.ts
···
1
+
import { EnvironmentConfigService } from '../shared/infrastructure/config/EnvironmentConfigService';
2
+
import { SyncWorkerProcess } from '../shared/infrastructure/processes/SyncWorkerProcess';
3
+
4
+
async function main() {
5
+
const configService = new EnvironmentConfigService();
6
+
const useInMemoryEvents = configService.shouldUseInMemoryEvents();
7
+
8
+
if (useInMemoryEvents) {
9
+
console.log('[SYNC] Skipping sync worker - using in-memory events');
10
+
return;
11
+
}
12
+
13
+
console.log('[SYNC] Starting sync worker...');
14
+
15
+
const syncWorkerProcess = new SyncWorkerProcess(configService);
16
+
await syncWorkerProcess.start();
17
+
}
18
+
19
+
main().catch((error) => {
20
+
console.error('[SYNC] Failed to start sync worker:', error);
21
+
process.exit(1);
22
+
});
+1
tsup.config.ts
+1
tsup.config.ts
···
7
7
'workers/search-worker': 'src/workers/search-worker.ts',
8
8
'workers/firehose-worker': 'src/workers/firehose-worker.ts',
9
9
'workers/notification-worker': 'src/workers/notification-worker.ts',
10
+
'workers/sync-worker': 'src/workers/sync-worker.ts',
10
11
},
11
12
outDir: 'dist',
12
13
target: 'node18',