duron 0.1.0

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/server.js

@@ -0,0 +1,516 @@
+import { Elysia } from 'elysia';
+import { jwtVerify, SignJWT } from 'jose';
+import { z } from 'zod';
+import { GetActionsResultSchema, GetJobStepsResultSchema, GetJobsResultSchema, JobSchema, JobSortFieldSchema, JobStatusResultSchema, JobStatusSchema, JobStepSchema, JobStepStatusResultSchema, SortOrderSchema, } from './adapters/schemas.js';
+export class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+}
+export class UnauthorizedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnauthorizedError';
+    }
+}
+export const GetJobStepsQuerySchema = z
+    .object({
+    page: z.coerce.number().int().min(1).optional(),
+    pageSize: z.coerce.number().int().min(1).max(1000).optional(),
+    search: z.string().optional(),
+    fUpdatedAfter: z.coerce.date().optional(),
+})
+    .transform((data) => ({
+    page: data.page,
+    pageSize: data.pageSize,
+    search: data.search,
+    updatedAfter: data.fUpdatedAfter,
+}));
+export const GetJobStepsResponseSchema = GetJobStepsResultSchema;
+export const GetJobsQuerySchema = z
+    .object({
+    page: z.coerce.number().int().min(1).optional(),
+    pageSize: z.coerce.number().int().min(1).max(1000).optional(),
+    fStatus: z.union([JobStatusSchema, z.array(JobStatusSchema)]).optional(),
+    fActionName: z.union([z.string(), z.array(z.string())]).optional(),
+    fGroupKey: z.union([z.string(), z.array(z.string())]).optional(),
+    fOwnerId: z.union([z.string(), z.array(z.string())]).optional(),
+    fCreatedAt: z.union([z.coerce.date(), z.array(z.coerce.date())]).optional(),
+    fStartedAt: z.union([z.coerce.date(), z.array(z.coerce.date())]).optional(),
+    fFinishedAt: z.union([z.coerce.date(), z.array(z.coerce.date())]).optional(),
+    fUpdatedAfter: z.coerce.date().optional(),
+    fSearch: z.string().optional(),
+    sort: z.string().optional(),
+    fInputFilter: z.record(z.string(), z.any()).optional(),
+    fOutputFilter: z.record(z.string(), z.any()).optional(),
+})
+    .transform((data) => {
+    const filters = {};
+    if (data.fStatus)
+        filters.status = data.fStatus;
+    if (data.fActionName)
+        filters.actionName = data.fActionName;
+    if (data.fGroupKey)
+        filters.groupKey = data.fGroupKey;
+    if (data.fOwnerId)
+        filters.ownerId = data.fOwnerId;
+    if (data.fCreatedAt)
+        filters.createdAt = data.fCreatedAt;
+    if (data.fStartedAt)
+        filters.startedAt = data.fStartedAt;
+    if (data.fFinishedAt)
+        filters.finishedAt = data.fFinishedAt;
+    if (data.fUpdatedAfter)
+        filters.updatedAfter = data.fUpdatedAfter;
+    if (data.fSearch)
+        filters.search = data.fSearch;
+    if (data.fInputFilter)
+        filters.inputFilter = data.fInputFilter;
+    if (data.fOutputFilter)
+        filters.outputFilter = data.fOutputFilter;
+    let sort;
+    if (data.sort) {
+        const sortParts = data.sort
+            .split(',')
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0);
+        const parsedSorts = sortParts
+            .map((part) => {
+            const [field, order] = part.split(':').map((s) => s.trim());
+            if (!field || !order) {
+                return null;
+            }
+            const fieldResult = JobSortFieldSchema.safeParse(field);
+            const orderResult = SortOrderSchema.safeParse(order.toLowerCase());
+            if (!fieldResult.success || !orderResult.success) {
+                return null;
+            }
+            return {
+                field: fieldResult.data,
+                order: orderResult.data,
+            };
+        })
+            .filter((s) => s !== null);
+        if (parsedSorts.length === 0) {
+            sort = undefined;
+        }
+        else {
+            sort = parsedSorts;
+        }
+    }
+    return {
+        page: data.page,
+        pageSize: data.pageSize,
+        filters: Object.keys(filters).length > 0 ? filters : undefined,
+        sort,
+    };
+});
+export const GetJobsResponseSchema = GetJobsResultSchema;
+export const GetActionsResponseSchema = GetActionsResultSchema;
+export const GetActionsMetadataResponseSchema = z.array(z.object({
+    name: z.string(),
+    mockInput: z.any(),
+}));
+export const ErrorResponseSchema = z.object({
+    error: z.string(),
+    message: z.string().optional(),
+});
+const JobIdParamsSchema = z.object({
+    id: z.uuid(),
+});
+const StepIdParamsSchema = z.object({
+    id: z.uuid(),
+});
+export const CancelJobResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string(),
+});
+export const RetryJobResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string(),
+    newJobId: z.string(),
+});
+export function createServer({ client, prefix, login }) {
+    const secretKey = typeof login?.jwtSecret === 'string' ? new TextEncoder().encode(login?.jwtSecret) : login?.jwtSecret;
+    const routePrefix = (prefix ?? '/api');
+    return new Elysia({
+        prefix: routePrefix,
+    })
+        .onError(({ code, error, set }) => {
+        if (code === 'VALIDATION') {
+            set.status = 400;
+            return error;
+        }
+        if (error instanceof NotFoundError) {
+            set.status = 404;
+            return {
+                error: 'Not found',
+                message: error.message,
+            };
+        }
+        if (error instanceof UnauthorizedError) {
+            set.status = 401;
+            return {
+                error: 'Unauthorized',
+                message: error.message,
+            };
+        }
+        set.status = code === 'NOT_FOUND' ? 404 : 500;
+        return {
+            error: 'Internal server error',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    })
+        .macro('getUser', {
+        headers: z.object({
+            authorization: z.string().optional(),
+        }),
+        resolve: async ({ headers }) => {
+            if (login) {
+                const authHeader = headers.authorization;
+                if (!authHeader) {
+                    return {
+                        user: null,
+                    };
+                }
+                const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : authHeader;
+                if (!token) {
+                    return {
+                        user: null,
+                    };
+                }
+                const { payload } = await jwtVerify(token, secretKey).catch(() => {
+                    return {
+                        payload: null,
+                    };
+                });
+                return {
+                    user: payload,
+                };
+            }
+            return {
+                user: null,
+            };
+        },
+    })
+        .macro('auth', {
+        getUser: true,
+        beforeHandle: async ({ user }) => {
+            if (login && !user) {
+                throw new UnauthorizedError('Unauthorized');
+            }
+        },
+    })
+        .get('/jobs/:id', async ({ params }) => {
+        const job = await client.getJobById(params.id);
+        if (!job) {
+            throw new NotFoundError(`Job with ID ${params.id} was not found`);
+        }
+        return job;
+    }, {
+        params: JobIdParamsSchema,
+        response: {
+            200: JobSchema,
+            404: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/jobs/:id/steps', async ({ params, query }) => {
+        const options = {
+            jobId: params.id,
+            page: query.page,
+            pageSize: query.pageSize,
+            search: query.search,
+            updatedAfter: query.updatedAfter,
+        };
+        return client.getJobSteps(options);
+    }, {
+        params: JobIdParamsSchema,
+        query: GetJobStepsQuerySchema,
+        response: {
+            200: GetJobStepsResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/jobs', async ({ query }) => {
+        const options = {
+            page: query.page,
+            pageSize: query.pageSize,
+            filters: query.filters,
+            sort: query.sort,
+        };
+        return client.getJobs(options);
+    }, {
+        query: GetJobsQuerySchema,
+        response: {
+            200: GetJobsResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/steps/:id', async ({ params }) => {
+        const step = await client.getJobStepById(params.id);
+        if (!step) {
+            throw new NotFoundError(`Step with ID ${params.id} was not found`);
+        }
+        return step;
+    }, {
+        params: StepIdParamsSchema,
+        response: {
+            200: JobStepSchema,
+            404: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/jobs/:id/status', async ({ params }) => {
+        const status = await client.getJobStatus(params.id);
+        if (!status) {
+            throw new NotFoundError(`Job with ID ${params.id} was not found`);
+        }
+        return status;
+    }, {
+        params: JobIdParamsSchema,
+        response: {
+            200: JobStatusResultSchema,
+            404: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/steps/:id/status', async ({ params }) => {
+        const status = await client.getJobStepStatus(params.id);
+        if (!status) {
+            throw new NotFoundError(`Step with ID ${params.id} was not found`);
+        }
+        return status;
+    }, {
+        params: StepIdParamsSchema,
+        response: {
+            200: JobStepStatusResultSchema,
+            404: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .post('/jobs/:id/cancel', async ({ params }) => {
+        await client.cancelJob(params.id);
+        return {
+            success: true,
+            message: `Job ${params.id} has been cancelled`,
+        };
+    }, {
+        params: JobIdParamsSchema,
+        response: {
+            200: CancelJobResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .post('/jobs/:id/retry', async ({ params }) => {
+        const newJobId = await client.retryJob(params.id);
+        if (!newJobId) {
+            throw new Error(`Could not retry job ${params.id}. The job may not be in a retryable state.`);
+        }
+        return {
+            success: true,
+            message: `Job ${params.id} has been retried`,
+            newJobId,
+        };
+    }, {
+        params: JobIdParamsSchema,
+        response: {
+            200: RetryJobResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .delete('/jobs/:id', async ({ params }) => {
+        const deleted = await client.deleteJob(params.id);
+        if (!deleted) {
+            throw new NotFoundError(`Job with ID ${params.id} was not found or cannot be deleted (active jobs cannot be deleted)`);
+        }
+        return {
+            success: true,
+            message: `Job ${params.id} has been deleted`,
+        };
+    }, {
+        params: JobIdParamsSchema,
+        response: {
+            200: z.object({
+                success: z.boolean(),
+                message: z.string(),
+            }),
+            404: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .delete('/jobs', async ({ query }) => {
+        const options = {
+            page: query.page,
+            pageSize: query.pageSize,
+            filters: query.filters,
+            sort: query.sort,
+        };
+        const deletedCount = await client.deleteJobs(options);
+        return {
+            success: true,
+            message: `Deleted ${deletedCount} job(s)`,
+            deletedCount,
+        };
+    }, {
+        query: GetJobsQuerySchema,
+        response: {
+            200: z.object({
+                success: z.boolean(),
+                message: z.string(),
+                deletedCount: z.number(),
+            }),
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/actions', async () => {
+        return client.getActions();
+    }, {
+        response: {
+            200: GetActionsResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .get('/actions/metadata', async () => {
+        return client.getActionsMetadata();
+    }, {
+        response: {
+            200: GetActionsMetadataResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .post('/actions/:actionName/run', async ({ params, body }) => {
+        const jobId = await client.runAction(params.actionName, body);
+        return {
+            success: true,
+            jobId,
+        };
+    }, {
+        params: z.object({
+            actionName: z.string(),
+        }),
+        body: z.any(),
+        response: {
+            200: z.object({
+                success: z.boolean(),
+                jobId: z.string(),
+            }),
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+            401: ErrorResponseSchema,
+        },
+        auth: true,
+    })
+        .post('/login', async ({ body }) => {
+        if (!login || !secretKey) {
+            throw new Error('Login is not configured');
+        }
+        const { email, password } = body;
+        const success = await login.onLogin({ email, password });
+        if (!success) {
+            throw new UnauthorizedError('Invalid credentials');
+        }
+        const accessToken = await new SignJWT({ email, type: 'access' })
+            .setProtectedHeader({ alg: 'HS256' })
+            .setIssuedAt()
+            .setExpirationTime(login.expirationTime ?? '1h')
+            .sign(secretKey);
+        const refreshToken = await new SignJWT({ email, type: 'refresh' })
+            .setProtectedHeader({ alg: 'HS256' })
+            .setIssuedAt()
+            .setExpirationTime(login.refreshTokenExpirationTime ?? '7d')
+            .sign(secretKey);
+        return {
+            accessToken,
+            refreshToken,
+        };
+    }, {
+        body: z.object({
+            email: z.email(),
+            password: z.string(),
+        }),
+        response: {
+            200: z.object({
+                accessToken: z.string(),
+                refreshToken: z.string(),
+            }),
+            401: ErrorResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+        },
+    })
+        .post('/refresh', async ({ body }) => {
+        if (!login || !secretKey) {
+            throw new Error('Login is not configured');
+        }
+        const { refreshToken: providedRefreshToken } = body;
+        if (!providedRefreshToken) {
+            throw new UnauthorizedError('Refresh token is required');
+        }
+        try {
+            const { payload } = await jwtVerify(providedRefreshToken, secretKey);
+            const typedPayload = payload;
+            if (typedPayload.type !== 'refresh') {
+                throw new UnauthorizedError('Invalid token type');
+            }
+            if (!typedPayload.email) {
+                throw new UnauthorizedError('Invalid token payload');
+            }
+            const accessToken = await new SignJWT({ email: typedPayload.email, type: 'access' })
+                .setProtectedHeader({ alg: 'HS256' })
+                .setIssuedAt()
+                .setExpirationTime(login.expirationTime ?? '1h')
+                .sign(secretKey);
+            return {
+                accessToken,
+            };
+        }
+        catch {
+            throw new UnauthorizedError('Invalid or expired refresh token');
+        }
+    }, {
+        body: z.object({
+            refreshToken: z.string(),
+        }),
+        response: {
+            200: z.object({
+                accessToken: z.string(),
+            }),
+            401: ErrorResponseSchema,
+            400: ErrorResponseSchema,
+            500: ErrorResponseSchema,
+        },
+    });
+}

package/dist/step-manager.d.ts

@@ -0,0 +1,46 @@
+import type { Logger } from 'pino';
+import type { z } from 'zod';
+import { type Action, type ActionHandlerContext, type StepHandlerContext, type StepOptions } from './action.js';
+import type { Adapter } from './adapters/adapter.js';
+import { type StepStatus } from './constants.js';
+export interface TaskStep {
+    name: string;
+    cb: (ctx: StepHandlerContext) => Promise<any>;
+    options: StepOptions;
+    abortSignal: AbortSignal;
+}
+export declare class StepStore {
+    #private;
+    constructor(adapter: Adapter);
+    getOrCreate(jobId: string, name: string, timeoutMs: number, retriesLimit: number): Promise<{
+        id: string;
+        status: "active" | "completed" | "failed" | "cancelled";
+        retriesLimit: number;
+        retriesCount: number;
+        timeoutMs: number;
+        error: any;
+        output: any;
+        isNew: boolean;
+    } | null>;
+    updateStatus(stepId: string, status: StepStatus, output?: any, error?: any): Promise<boolean>;
+    delay(stepId: string, delayMs: number, error: any): Promise<boolean>;
+}
+export interface StepManagerOptions {
+    jobId: string;
+    actionName: string;
+    adapter: Adapter;
+    logger: Logger;
+    concurrencyLimit: number;
+}
+export declare class StepManager {
+    #private;
+    constructor(options: StepManagerOptions);
+    createActionContext<TInput extends z.ZodObject, TOutput extends z.ZodObject, TVariables = Record<string, unknown>>(job: {
+        id: string;
+        input: z.infer<TInput>;
+        groupKey?: string;
+    }, action: Action<TInput, TOutput, TVariables>, variables: TVariables, abortSignal: AbortSignal, logger: Logger): ActionHandlerContext<TInput, TVariables>;
+    push(task: TaskStep): Promise<any>;
+    drain(): Promise<void>;
+}
+//# sourceMappingURL=step-manager.d.ts.map

package/dist/step-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-manager.d.ts","sourceRoot":"","sources":["../src/step-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAClC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EACL,KAAK,MAAM,EACX,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAEjB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAgC,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAoE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAalH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;IAC7C,OAAO,EAAE,WAAW,CAAA;IACpB,WAAW,EAAE,WAAW,CAAA;CACzB;AAMD,qBAAa,SAAS;;gBAYR,OAAO,EAAE,OAAO;IAkBtB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;;;;;;;IAsBhF,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB7F,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;CAG3E;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAMD,qBAAa,WAAW;;gBAkBV,OAAO,EAAE,kBAAkB;IA6BvC,mBAAmB,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EAAE,OAAO,SAAS,CAAC,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/G,GAAG,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,EAC9D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,EAC3C,SAAS,EAAE,UAAU,EACrB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,GACb,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC;IAUrC,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAQlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAkK7B"}