@appconda/nextjs 1.0.161 → 1.0.171

package/src/modules/scheduled-job/lib/Schedules.ts

@@ -0,0 +1,105 @@
+
+type TaskPayload = {
+    timestamp: Date;
+    lastTimestamp?: Date;
+    timezone: string;
+};
+
+type TaskContext = {
+    retriesLeft: number;
+};
+
+type TaskArgs = {
+    id: string;
+    name: string;
+    cron: string;
+    maxDuration?: number; // saniye
+    retries?: number;
+    run: (
+        payload: TaskPayload,
+        tools: { ctx: TaskContext }
+    ) => Promise<void> | void;
+};
+
+export class Schedules {
+    private lastRunTimestamps: Record<string, Date> = {};
+    private Tasks: TaskArgs[] = [];
+
+    public task(args: TaskArgs) {
+        this.Tasks.push(args);
+    }
+
+    public async run(taskId: string) {
+        const now = new Date();
+        const lastTimestamp = this.lastRunTimestamps[taskId];
+
+        const payload: TaskPayload = {
+            timestamp: now,
+            lastTimestamp,
+            timezone: "UTC",
+        };
+
+        this.lastRunTimestamps[taskId] = now;
+
+        const context: TaskContext = {
+            retriesLeft: this.Tasks.find(task => task.id === taskId)?.retries ?? 0,
+        };
+
+        await this.runWithRetry(this.Tasks.find(task => task.id === taskId)!, payload, context);
+
+
+    }
+
+    private async runWithRetry(
+        task: TaskArgs,
+        payload: TaskPayload,
+        ctx: TaskContext
+    ) {
+        const start = Date.now();
+
+        try {
+            await Promise.race([
+                task.run(payload, { ctx }),
+                timeout(task.maxDuration ?? 60),
+            ]);
+            log("success", { taskId: task.id, name: task.name, time: new Date().toISOString() });
+        } catch (err) {
+            //@ts-ignore
+            log("error", { taskId: task.id, name: task.name, error: err });
+
+            if (ctx.retriesLeft > 0) {
+                ctx.retriesLeft -= 1;
+                //@ts-ignore
+                log("warn", { taskId: task.id, name: task.name, msg: "Retrying..." });
+                await this.runWithRetry(task, payload, ctx);
+            }
+        } finally {
+            const duration = Date.now() - start;
+            //@ts-ignore
+            log("info", { taskId: task.id, name: task.name, durationMs: duration });
+        }
+    }
+
+    public toJSON() {
+        return this.Tasks.map(task => ({
+            id: task.id,
+            name: task.name,
+            cron: task.cron,
+            maxDuration: task.maxDuration,
+            retries: task.retries,
+        }));
+    }
+}
+
+function log(arg0: string, arg1: { taskId: string; name: string; time: string; }) {
+    // console.log(arg0, arg1);
+}
+
+function timeout(seconds: number) {
+    return new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("Timeout reached")), seconds * 1000)
+    );
+}
+
+
+export const schedules = new Schedules();

package/src/modules/scheduled-job/lib/handler.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+import './jobs';
+import { schedules } from './Schedules';
+
+/* export async function GET() {
+  return NextResponse.json({ schedules: schedules.toJSON() },
+    { status: 200 });
+}
+
+export async function POST(request: Request) {
+
+} */
+
+export async function scheduledJobHandler(request: NextRequest, res: NextResponse) {
+  if (request.method === 'POST') {
+    const body = await request.json();
+    const taskId = body.taskId;
+    schedules.run(taskId);
+    return NextResponse.json({ message: 'Callback triggered' },
+      { status: 200 });
+  } else {
+    return NextResponse.json({ schedules: schedules.toJSON() },
+      { status: 200 });
+  }
+} 
+

package/src/modules/scheduled-job/lib/jobs/index.ts

@@ -0,0 +1,2 @@
+
+import './job1';

package/src/modules/scheduled-job/lib/jobs/job1.ts

@@ -0,0 +1,12 @@
+import { schedules } from "../Schedules";
+
+schedules.task({
+    name: "report",
+    id: "report",
+    cron: "*/50 * * * *",
+    run: async () => {
+        console.log("hello from job 1");
+    },
+});
+
+

package/src/modules/scheduled-job/lib/wait.ts

@@ -0,0 +1,17 @@
+export const wait = {
+    for: ({ seconds }: { seconds: number }) =>
+      new Promise((resolve) => setTimeout(resolve, seconds * 1000)),
+  
+    until: ({ date }: { date: Date }) => {
+      const now = new Date();
+      const diff = date.getTime() - now.getTime();
+  
+      if (diff <= 0) {
+        // Hedef tarih zaten geçmişse hiç bekleme
+        return Promise.resolve();
+      }
+  
+      return new Promise((resolve) => setTimeout(resolve, diff));
+    },
+  };
+  

package/src/modules/scheduled-job/schema.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+export const CreateScheduledJobSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    cron: z.string(),
+    enabled: z.boolean().optional().default(true),
+});
+
+export const ListScheduledJobsSchema = z.object({
+   
+});
+
+export const GetScheduledJobSchema = z.object({
+    id: z.string()
+});
+
+export const ListExecutionsSchema = z.object({
+    scheduledJobId: z.string(),
+    status: z.string().optional()
+});
+    
+export const ListAvgExecutionsSchema = z.object({
+});
+
+export const UpdateJobSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    cron: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+
+    
+export const GetDailyExecutionTrendSchema = z.object({
+   
+});
+
+export const GetTopFailedJobsSchema = z.object({
+   
+});
+
+export const GetJobStatsSchema = z.object({
+   
+});
+
+export const DeleteJobSchema = z.object({
+    id: z.string()
+});
+
+export const QueueJobSchema = z.object({
+    id: z.string()
+});
+

package/src/modules/scheduled-job/service.ts

@@ -0,0 +1,60 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateScheduledJobSchema, ListScheduledJobsSchema, GetScheduledJobSchema, ListExecutionsSchema, GetDailyExecutionTrendSchema, GetTopFailedJobsSchema, GetJobStatsSchema, ListAvgExecutionsSchema, UpdateJobSchema, DeleteJobSchema, QueueJobSchema } from "./schema";
+import { AvgExecution, Execution, ExecutionTrend, FailedJob, JobMetrics, JobStats, ScheduledJob } from "./types";
+
+export class ScheduledJobService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.scheduled-jobs';
+    }
+
+    public async CreateScheduledJob(payload: z.infer<typeof CreateScheduledJobSchema>): Promise<ScheduledJob> {
+        return await this.actionCall('CreateScheduledJob', payload);
+    }
+
+    public async ListScheduledJobs(payload: z.infer<typeof ListScheduledJobsSchema>): Promise<ScheduledJob[]> {
+        return await this.actionCall('ListScheduledJobs', payload);
+    }
+
+    public async GetScheduledJob(payload: z.infer<typeof GetScheduledJobSchema>): Promise<ScheduledJob> {
+        return await this.actionCall('GetScheduledJob', payload);
+    }
+
+    public async ListExecutions(payload: z.infer<typeof ListExecutionsSchema>): Promise<Execution[]> {
+        return await this.actionCall('ListExecutions', payload);
+    }
+
+    public async ListAvgExecutions(payload: z.infer<typeof ListAvgExecutionsSchema>): Promise<AvgExecution[]> {
+        return await this.actionCall('ListAvgExecutions', payload);
+    }
+
+    public async UpdateJob(payload: z.infer<typeof UpdateJobSchema>): Promise<ScheduledJob> {
+        return await this.actionCall('UpdateJob', payload);
+    }
+
+    public async GetDailyExecutionTrend(payload: z.infer<typeof GetDailyExecutionTrendSchema>): Promise<ExecutionTrend[]> {
+        return await this.actionCall('GetDailyExecutionTrend', payload);
+    }
+
+    public async GetTopFailedJobs(payload: z.infer<typeof GetTopFailedJobsSchema>): Promise<FailedJob> {
+        return await this.actionCall('GetTopFailedJobs', payload);
+    }
+
+    public async GetJobStats(payload: z.infer<typeof GetJobStatsSchema>): Promise<JobStats> {
+        return await this.actionCall('GetJobStats', payload);
+    }
+
+    public async DeleteJob(payload: z.infer<typeof DeleteJobSchema>): Promise<void> {
+        return await this.actionCall('DeleteJob', payload);
+    }
+
+    public async GetJobMetrics(): Promise<JobMetrics> {
+        return await this.actionCall('GetJobMetrics', {});
+    }
+
+    public async QueueJob(payload: z.infer<typeof QueueJobSchema>): Promise<void> {
+        return await this.actionCall('QueueJob', payload);
+    }
+    
+}

package/src/modules/scheduled-job/types.ts

@@ -0,0 +1,78 @@
+
+
+export type ScheduledJob = {
+  id: string;
+  name: string;
+  description: string;
+  cron: string;
+  enabled: boolean;
+  lastRun?: Date;
+  nextRun?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type JobRun = {
+  id: string;
+  jobId: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type Execution = {
+  id: string;
+  scheduledJobId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  status: string;
+}
+
+
+export type AvgExecution = {
+  scheduledJobId: string;
+  totalExecutions: number;
+  activeDays: number;
+  avgExecutionsPerDay: number;
+  completed: number;
+  failed: number;
+  queued: number;
+}
+
+
+
+export type ExecutionTrend = {
+  labels: string[];
+  datasets: {
+    label: string;
+    data: number[];
+    borderColor: string;
+  }
+}
+
+export type FailedJob = {
+  labels: string[];
+  datasets: {
+    label: string;
+    data: number[];
+    backgroundColor: string;
+  }[];
+}
+
+export type JobStats = {
+  scheduledJobId: string;
+  total: number;
+  completed: number;
+  failed: number;
+  queued: number;
+  avgDay: number;
+  avgDuration: number;
+  lastRun: string;
+}
+
+export type JobMetrics = {
+  totalExecutions: number;
+  completed: number;
+  failed: number;
+  queued: number;
+  
+}

package/src/modules/task/action.ts

@@ -0,0 +1,167 @@
+'use server';
+
+
+import { z } from 'zod';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { CreateProjectSchema, CreateSprintSchema, CreateTaskListSchema, DeleteExecutionsSchema, DeleteSprintSchema, DeleteTaskListSchema, GetSprintSchema, GetTaskListSchema, ListProjectsSchema, UpdateSprintSchema, UpdateTaskListSchema } from './schema';
+import { Project, Sprint, TaskList } from './types';
+
+export const CreateProject = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateProjectSchema> }): Promise<{data?: Project, serverError?: string}> => {
+    try {
+        const { task } = await getSDKForCurrentUser();
+        //@ts-ignore
+        return { data: await task.CreateProject(parsedInput) };
+
+        } catch (error) {
+            console.error('Error in CreateProject:', error);
+            return { serverError: error.toString() };
+        }
+    };
+
+    export const ListProjects = async ({ parsedInput }: { parsedInput: z.infer<typeof ListProjectsSchema> }): Promise<{data?: Project[], serverError?: string}> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            //@ts-ignore
+            return { data: await task.ListProjects(parsedInput) };
+
+        } catch (error) {
+            console.error('Error in ListProjects:', error);
+            return { serverError: error.toString() };
+        }
+    };
+
+export const CreateTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.CreateTaskList(parsedInput) };
+
+        } catch (error) {
+            console.error('Error in CreateTaskList:', error);
+            return { serverError: error.toString() };
+        }
+    };
+
+export const GetTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof GetTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.GetTaskList(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+
+
+export const ListTaskLists = async (): Promise<{data?: TaskList[], serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.ListTaskLists() };
+
+    } catch (error) {
+        console.error('Error in ListTaskLists:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const UpdateTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof UpdateTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.UpdateTaskList(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in UpdateTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const DeleteTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof DeleteTaskListSchema> }): Promise<{data?: void, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.DeleteTaskList(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in DeleteTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const CreateSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateSprintSchema> }): Promise<{data?: Sprint, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.CreateSprint(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in CreateSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const GetSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof GetSprintSchema> }): Promise<{data?: Sprint, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.GetSprint(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
+//@ts-ignore
+export const ListSprints = async ({ parsedInput }: { parsedInput: z.infer<typeof ListSprintsSchema> }): Promise<{data?: Sprint[], serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.ListSprints() };
+
+    } catch (error) {
+        console.error('Error in ListSprints:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const UpdateSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof UpdateSprintSchema> }): Promise<{data?: Sprint, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.UpdateSprint(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in UpdateSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const DeleteSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof DeleteSprintSchema> }): Promise<{data?: void, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.DeleteSprint(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in DeleteSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const DeleteExecutions = async ( parsedInput: z.infer<typeof DeleteExecutionsSchema> ): Promise<{data?: void, serverError?: string}> => {
+    try {
+
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.DeleteExecutions(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in DeleteExecutions:', error);
+        return { serverError: error.toString() };
+    }
+};
+    

package/src/modules/task/index.ts

@@ -0,0 +1,4 @@
+export * from './action';
+export * from './schema';
+export * from './service';
+export * from './types';

package/src/modules/task/schema.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+
+export const CreateProjectSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    ownerId: z.string(),
+    title: z.string(),
+    description: z.string().optional()
+});
+
+export const ListProjectsSchema = z.object({
+    tenantId: z.string()
+});
+
+export const CreateTaskListSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    description: z.string().optional()
+});
+
+export const CreateSprintSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    description: z.string().optional()
+});
+
+export const GetTaskListSchema = z.object({
+    id: z.string()
+});
+
+export const GetSprintSchema = z.object({
+    id: z.string()
+});
+
+export const UpdateTaskListSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().optional()
+});
+
+export const UpdateSprintSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().optional()
+});
+
+export const DeleteTaskListSchema = z.object({
+    id: z.string()
+});
+
+export const DeleteSprintSchema = z.object({
+    id: z.string()
+});
+
+export const DeleteExecutionsSchema = z.object({
+    jobId: z.string(),
+    status: z.string()
+});

package/src/modules/task/service.ts

@@ -0,0 +1,65 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateProjectSchema, CreateSprintSchema, CreateTaskListSchema, DeleteExecutionsSchema, DeleteSprintSchema, DeleteTaskListSchema, GetSprintSchema, GetTaskListSchema, ListProjectsSchema, UpdateSprintSchema, UpdateTaskListSchema } from "./schema";
+import { Project, Sprint, TaskList } from "./types";
+
+
+export class TaskService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.task';
+    }
+
+    public async CreateProject(payload: z.infer<typeof CreateProjectSchema>): Promise<Project> {
+        return await this.actionCall('CreateProject', payload);
+    }
+
+    public async ListProjects(payload: z.infer<typeof ListProjectsSchema>): Promise<Project[]> {
+        return await this.actionCall('ListProjects', payload);
+    }
+
+    public async CreateTaskList(payload: z.infer<typeof CreateTaskListSchema>): Promise<TaskList> {
+        return await this.actionCall('CreateTaskList', payload);
+    }
+
+    public async CreateSprint(payload: z.infer<typeof CreateSprintSchema>): Promise<Sprint> {
+        return await this.actionCall('CreateSprint', payload);
+    }
+
+    public async ListTaskLists(): Promise<TaskList[]> {
+        return await this.actionCall('ListTaskLists', {});
+    }
+
+    public async ListSprints(): Promise<Sprint[]> {
+        return await this.actionCall('ListSprints', {});
+    }
+
+    public async GetTaskList(payload: z.infer<typeof GetTaskListSchema>): Promise<TaskList> {
+        return await this.actionCall('GetTaskList', payload);
+    }
+
+    public async GetSprint(payload: z.infer<typeof GetSprintSchema>): Promise<Sprint> {
+        return await this.actionCall('GetSprint', payload);
+    }
+
+    public async UpdateTaskList(payload: z.infer<typeof UpdateTaskListSchema>): Promise<TaskList> {
+        return await this.actionCall('UpdateTaskList', payload);
+    }
+
+    public async UpdateSprint(payload: z.infer<typeof UpdateSprintSchema>): Promise<Sprint> {
+        return await this.actionCall('UpdateSprint', payload);
+    }
+
+    public async DeleteTaskList(payload: z.infer<typeof DeleteTaskListSchema>): Promise<void> {
+        return await this.actionCall('DeleteTaskList', payload);
+    }
+
+    public async DeleteSprint(payload: z.infer<typeof DeleteSprintSchema>): Promise<void> {
+        return await this.actionCall('DeleteSprint', payload);
+    }
+
+    public async DeleteExecutions(payload: z.infer<typeof DeleteExecutionsSchema>): Promise<void> {
+        return await this.actionCall('DeleteExecutions', payload);
+    }
+
+}