@appconda/nextjs 1.0.160 → 1.1.2

package/src/modules/account/actions.ts

@@ -10,7 +10,7 @@ export const CreateUser = actionClient
     .schema(CreateUserSchema)
     .action(async ({ parsedInput }): Promise<User> => {
         try {
-            const { userId, email, password, name } = parsedInput;
+            const { userId, email, password, name } = parsedInput as any;
             const { accounts } = await getSDKForCurrentUser();
             return await accounts.create(userId, email, password, name);
 

package/src/modules/acl/service.ts

@@ -0,0 +1,55 @@
+
+import { Payload } from "../../client";
+import { ServiceClient } from "../../service-client";
+
+type Blacklist = {
+    id: string
+    createdAt: Date
+    type: string
+    value: string
+    active: boolean
+    registerAttempts: number
+}
+
+export class Acl extends ServiceClient {
+
+    protected getServiceName(): string {
+        return 'com.appconda.service.acl';
+    }
+
+    public async getBlacklist(
+        filters?: any,
+        pagination?: { page: number; pageSize: number }
+    ): Promise<{ items: Blacklist[]; pagination: any }> {
+
+        const payload: Payload = {};
+
+        return await this.actionCall('GetBlackList', payload);
+
+    }
+
+    public async addToBlackList(type: string, value: string ): Promise<Blacklist> {
+
+        const payload: Payload = {};
+        payload['type'] = type;
+        payload['value'] = value;
+        return await this.actionCall('AddToBlackList', payload);
+
+    }
+
+    public async deleteFromBlackList(type: string, value: string ): Promise<boolean> {
+
+        const payload: Payload = {};
+        payload['type'] = type;
+        payload['value'] = value;
+        return await this.actionCall('DeleteFromBlackList', payload);
+
+    }
+
+    public async getAllTenantIpAddresses(): Promise<{ items: any[]; pagination: any }> {
+
+        const payload: Payload = {};
+        return await this.actionCall('GetAllTenantIpAddresses', payload);
+
+    }
+}

package/src/modules/agent/action.ts

@@ -75,3 +75,5 @@ export const ListModels = actionClient
             throw new Error('Failed to fetch ListModels');
         }
     });
+
+    

package/src/modules/ai/node/actions.ts

@@ -1,8 +1,7 @@
 'use server';
 
-import { getSDKForCurrentUser } from "@appconda/nextjs";
-import { z } from "zod";
 import { actionClient } from "../../../actions/actionClient";
+import { getSDKForCurrentUser } from "../../../getSDKForCurrentUser";
 
 export const getAllNodesAction = actionClient
     // .schema(listModelsSchema)

package/src/modules/index.ts

@@ -1,4 +1,7 @@
 export * from './waitlist';
 export * from './account';
 export * from './ai';
-export * from './agent';
+export * from './agent';
+export * from './tenant';
+export * from './task';
+export * from './scheduled-job';

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

@@ -0,0 +1,94 @@
+'use server';
+
+
+import { actionClient } from '../../actions/actionClient';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { CreateScheduledJobSchema, GetScheduledJobSchema, ListAvgExecutionsSchema, ListExecutionsSchema, ListScheduledJobsSchema, UpdateJobSchema } from './schema';
+import { AvgExecution, Execution, ScheduledJob } from './types';
+
+export const CreateScheduledJob = actionClient
+    .schema(CreateScheduledJobSchema)
+    .action(async ({ parsedInput }): Promise<ScheduledJob> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.CreateScheduledJob(parsedInput);
+
+        } catch (error) {
+            console.error('Error in CreateScheduledJob:', error);
+            throw new Error('Failed to fetch CreateScheduledJob');
+        }
+    });
+
+    export const ListScheduledJobs = actionClient
+    .schema(ListScheduledJobsSchema)
+    .action(async ({ parsedInput }): Promise<ScheduledJob[]> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.ListScheduledJobs(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListScheduledJobs:', error);
+            throw new Error('Failed to fetch ListScheduledJobs');
+        }
+    });
+
+    export const GetScheduledJob = actionClient
+    .schema(GetScheduledJobSchema)
+    .action(async ({ parsedInput }): Promise<ScheduledJob> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.GetScheduledJob(parsedInput);
+
+        } catch (error) {
+            console.error('Error in GetScheduledJob:', error);
+            throw new Error('Failed to fetch GetScheduledJob');
+        }
+    });
+    
+    export const ListExecutions = actionClient
+    .schema(ListExecutionsSchema)
+    .action(async ({ parsedInput }): Promise<Execution[]> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.ListExecutions(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListExecutions:', error);
+            throw new Error('Failed to fetch ListExecutions');
+        }
+    });
+    
+    export const ListAvgExecutions = actionClient
+    .schema(ListAvgExecutionsSchema)
+    .action(async ({ parsedInput }): Promise<AvgExecution[]> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.ListAvgExecutions(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListAvgExecutions:', error);
+            throw new Error('Failed to fetch ListAvgExecutions');
+        }
+    });
+
+    export const UpdateJob = actionClient
+    .schema(UpdateJobSchema)
+    .action(async ({ parsedInput }): Promise<ScheduledJob> => {
+        try {
+
+            const { scheduledJob } = await getSDKForCurrentUser();
+            return await scheduledJob.UpdateJob(parsedInput);
+
+        } catch (error) {
+            console.error('Error in UpdateJob:', error);
+            throw new Error('Failed to fetch UpdateJob');
+        }
+    });         
+
+
+            

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

@@ -0,0 +1,8 @@
+export * from './action';
+export * from './schema';
+export * from './service';
+export * from './types';
+export * from './lib/Schedules';
+export * from './lib/handler';
+
+import './lib/jobs';

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

@@ -0,0 +1,103 @@
+
+type TaskPayload = {
+    timestamp: Date;
+    lastTimestamp?: Date;
+    timezone: string;
+};
+
+type TaskContext = {
+    retriesLeft: number;
+};
+
+type TaskArgs = {
+    id: 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, time: new Date().toISOString() });
+        } catch (err) {
+            //@ts-ignore
+            log("error", { taskId: task.id, error: err });
+
+            if (ctx.retriesLeft > 0) {
+                ctx.retriesLeft -= 1;
+                //@ts-ignore
+                log("warn", { taskId: task.id, msg: "Retrying..." });
+                await this.runWithRetry(task, payload, ctx);
+            }
+        } finally {
+            const duration = Date.now() - start;
+            //@ts-ignore
+            log("info", { taskId: task.id, durationMs: duration });
+        }
+    }
+
+    public toJSON() {
+        return this.Tasks.map(task => ({
+            id: task.id,
+            cron: task.cron,
+            maxDuration: task.maxDuration,
+            retries: task.retries,
+        }));
+    }
+}
+
+function log(arg0: string, arg1: { taskId: 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 './log-job';
+import './job1';

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

@@ -0,0 +1,34 @@
+import { schedules } from "../Schedules";
+
+schedules.task({
+    id: "job1",
+    cron: "*/5 * * * *",
+    run: async () => {
+        console.log("hello from job 1");
+    },
+});
+
+
+schedules.task({
+    id: "job2",
+    cron: "*/5 * * * *",
+    run: async () => {
+        console.log("hello from job 2");
+    },
+});
+
+schedules.task({
+    id: "job3",
+    cron: "*/5 * * * *",
+    run: async () => {
+        console.log("hello from job 3");
+    },
+});
+
+schedules.task({
+    id: "job4",
+    cron: "*/5 * * * *",
+    run: async () => {
+        console.log("hello from job 4");
+    },
+});

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

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

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,31 @@
+import { z } from "zod";
+
+export const CreateScheduledJobSchema = z.object({
+    id: z.string().optional(),
+    name: z.string(),
+    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(),
+    cron: z.string().optional(),
+    enabled: z.boolean().optional(),
+});

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

@@ -0,0 +1,37 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateScheduledJobSchema, ListScheduledJobsSchema, GetScheduledJobSchema, ListExecutionsSchema, ListAvgExecutionsSchema, UpdateJobSchema } from "./schema";
+import { AvgExecution, Execution, 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);
+    }
+
+ 
+}

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

@@ -0,0 +1,35 @@
+
+
+export type ScheduledJob = {
+  id: string;
+  name: 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;
+}
+

package/src/modules/task/action.ts

@@ -0,0 +1,175 @@
+'use server';
+
+
+import { actionClient } from '../../actions/actionClient';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { getSDKForService } from '../../getSDKForService';
+import { CreateProjectSchema, CreateSprintSchema, CreateTaskListSchema, DeleteSprintSchema, DeleteTaskListSchema, GetSprintSchema, GetTaskListSchema, ListProjectsSchema, UpdateSprintSchema, UpdateTaskListSchema } from './schema';
+import { Project, Sprint, TaskList } from './types';
+
+export const CreateProject = actionClient
+    .schema(CreateProjectSchema)
+    .action(async ({ parsedInput }): Promise<Project> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.CreateProject(parsedInput);
+
+        } catch (error) {
+            console.error('Error in CreateProject:', error);
+            throw new Error('Failed to fetch CreateProject');
+        }
+    });
+
+    export const ListProjects = actionClient
+    .schema(ListProjectsSchema)
+    .action(async ({ parsedInput }): Promise<Project[]> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.ListProjects(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListProjects:', error);
+            throw new Error('Failed to fetch ListProjects');
+        }
+    });
+
+export const CreateTaskList = actionClient
+    .schema(CreateTaskListSchema)
+    .action(async ({ parsedInput }): Promise<TaskList> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.CreateTaskList(parsedInput);
+
+        } catch (error) {
+            console.error('Error in CreateTaskList:', error);
+            throw new Error('Failed to fetch CreateTaskList');
+        }
+    });
+
+export const GetTaskList = actionClient
+    .schema(GetTaskListSchema)
+    .action(async ({ parsedInput }): Promise<TaskList> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.GetTaskList(parsedInput);
+
+        } catch (error) {
+            console.error('Error in GetTaskList:', error);
+            throw new Error('Failed to fetch GetTaskList');
+        }
+    });
+
+export const ListTaskLists = actionClient
+    .action(async ({ parsedInput }): Promise<TaskList[]> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.ListTaskLists();
+
+        } catch (error) {
+            console.error('Error in ListTaskLists:', error);
+            throw new Error('Failed to fetch ListTaskLists');
+        }
+    });
+
+export const UpdateTaskList = actionClient
+    .schema(UpdateTaskListSchema)
+    .action(async ({ parsedInput }): Promise<TaskList> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.UpdateTaskList(parsedInput);
+
+        } catch (error) {
+            console.error('Error in UpdateTaskList:', error);
+            throw new Error('Failed to fetch UpdateTaskList');
+        }
+    });
+
+export const DeleteTaskList = actionClient
+    .schema(DeleteTaskListSchema)
+    .action(async ({ parsedInput }): Promise<void> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.DeleteTaskList(parsedInput);
+
+        } catch (error) {
+            console.error('Error in DeleteTaskList:', error);
+            throw new Error('Failed to fetch DeleteTaskList');
+        }
+    });
+    
+    
+    export const CreateSprint = actionClient
+    .schema(CreateSprintSchema)
+    .action(async ({ parsedInput }): Promise<Sprint> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.CreateSprint(parsedInput);
+
+        } catch (error) {
+            console.error('Error in CreateSprint:', error);
+            throw new Error('Failed to fetch CreateSprint');
+        }
+    });
+
+export const GetSprint = actionClient
+    .schema(GetSprintSchema)
+    .action(async ({ parsedInput }): Promise<Sprint> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.GetSprint(parsedInput);
+
+        } catch (error) {
+            console.error('Error in GetSprint:', error);
+            throw new Error('Failed to fetch GetSprint');
+        }
+    });
+    
+    export const ListSprints = actionClient
+    .action(async ({ parsedInput }): Promise<Sprint[]> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.ListSprints();
+
+        } catch (error) {
+            console.error('Error in ListSprints:', error);
+            throw new Error('Failed to fetch ListSprints');
+        }
+    });
+    
+    export const UpdateSprint = actionClient
+    .schema(UpdateSprintSchema)
+    .action(async ({ parsedInput }): Promise<Sprint> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.UpdateSprint(parsedInput);
+
+        } catch (error) {
+            console.error('Error in UpdateSprint:', error);
+            throw new Error('Failed to fetch UpdateSprint');
+        }
+    });
+    
+    export const DeleteSprint = actionClient
+    .schema(DeleteSprintSchema)
+    .action(async ({ parsedInput }): Promise<void> => {
+        try {
+
+            const { task } = await getSDKForCurrentUser();
+            return await task.DeleteSprint(parsedInput);
+
+        } catch (error) {
+            console.error('Error in DeleteSprint:', error);
+            throw new Error('Failed to fetch DeleteSprint');
+        }
+    });

package/src/modules/task/index.ts

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