@appconda/nextjs 1.0.161 → 1.0.172

package/src/modules/account/actions.ts

@@ -1,21 +1,24 @@
 'use server';
 
-import { actionClient } from "../../actions/actionClient";
+import { z } from "zod";
 import { getSDKForCurrentUser } from "../../getSDKForCurrentUser";
 import { CreateUserSchema } from "./schema";
 import { User } from "./types";
 
 
-export const CreateUser = actionClient
-    .schema(CreateUserSchema)
-    .action(async ({ parsedInput }): Promise<User> => {
-        try {
-            const { userId, email, password, name } = parsedInput;
-            const { accounts } = await getSDKForCurrentUser();
-            return await accounts.create(userId, email, password, name);
+export const CreateUser = async (params: z.infer<typeof CreateUserSchema>): Promise<{ data?: User, serverError?: string }> => {
+    try {
+        const { userId, email, password, name } = params;
+        const { accounts } = await getSDKForCurrentUser();
+        return {
+            //@ts-ignore
+            data: await accounts.create(userId, email, password, name) as any
+        };
 
-        } catch (error) {
-            console.error('Error in ListWaitlists:', error);
-            throw new Error('Failed to fetch ListWaitlists');
-        }
-    });
+    } catch (error) {
+        console.error('Error in CreateUser:', error);
+        return {
+            serverError: error.toString()
+        };
+    }
+};

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

@@ -1,77 +1,66 @@
 'use server';
 
 
-import { actionClient } from '../../actions/actionClient';
+import { z } from 'zod';
 import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
-import { getSDKForService } from '../../getSDKForService';
-import { CreateAgentSchema, GetAgentSchema, ListModelsSchema } from './schema';
 import { Agent, AIModel } from './types';
+import { CreateAgentSchema, GetAgentSchema, ListModelsSchema } from './schema';
 
 
-export const ListAgents = actionClient
-    //.schema(ListWaitlistSignupsSchema)
-    .action(async ({ parsedInput }): Promise<Agent[]> => {
+export const ListAgents = async (): Promise<{data?: Agent[], serverError?: string}> => {
         try {
-
             const { agent } = await getSDKForCurrentUser();
-            return await agent.ListAgents(); // typo: Wiatlist mi?
+            return { data: await agent.ListAgents() };
         } catch (error) {
-            console.error('Error in ListWaitlistSignups:', error);
-            throw new Error('Failed to fetch ListWaitlistSignups');
+            console.error('Error in ListAgents:', error);
+            return { serverError: error.toString() };
         }
-    });
+    };
 
 
 
-export const CreateAgent = actionClient
-    .schema(CreateAgentSchema)
-    .action(async ({ parsedInput }): Promise<Agent> => {
+export const CreateAgent = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateAgentSchema> }): Promise<{data?: Agent, serverError?: string}> => {
         try {
-
             const { agent } = await getSDKForCurrentUser();
-            return await agent.CreateAgent(parsedInput);
+            return { data: await agent.CreateAgent(parsedInput) };
 
         } catch (error) {
-            console.error('Error in ListWaitlists:', error);
-            throw new Error('Failed to fetch ListWaitlists');
+            console.error('Error in CreateAgent:', error);
+            return { serverError: error.toString() };
         }
-    });
+    };
 
-export const GetAgent = actionClient
-    .schema(GetAgentSchema)
-    .action(async ({ parsedInput }): Promise<Agent> => {
+export const GetAgent = async ({ parsedInput }: { parsedInput: z.infer<typeof GetAgentSchema> }): Promise<{data?: Agent, serverError?: string}> => {
         try {
-
             const { agent } = await getSDKForCurrentUser();
-            return await agent.GetAgent(parsedInput);
+            return { data: await agent.GetAgent(parsedInput) };
 
         } catch (error) {
-            console.error('Error in ListWaitlists:', error);
-            throw new Error('Failed to fetch ListWaitlists');
+            console.error('Error in GetAgent:', error);
+            return { serverError: error.toString() };
         }
-    });
+    };
 
-export const ListModelProviders = actionClient
-    .action(async ({ parsedInput }): Promise<Agent[]> => {
+export const ListModelProviders = async (): Promise<{data?: Agent[], serverError?: string}> => {
         try {
 
             const { agent } = await getSDKForCurrentUser();
-            return await agent.ListModelProviders();
+            return { data: await agent.ListModelProviders() };
         } catch (error) {
             console.error('Error in ListModelProviders:', error);
-            throw new Error('Failed to fetch ListModelProviders');
+            return { serverError: error.toString() };
         }
-    });
+    }
 
-export const ListModels = actionClient
-    .schema(ListModelsSchema)
-    .action(async ({ parsedInput }): Promise<AIModel[]> => {
+export const ListModels = async ({ parsedInput }: { parsedInput: z.infer<typeof ListModelsSchema> }): Promise<{data?: AIModel[], serverError?: string}> => {
         try {
 
             const { agent } = await getSDKForCurrentUser();
-            return await agent.ListModels(parsedInput);
+            return { data: await agent.ListModels(parsedInput) };
         } catch (error) {
             console.error('Error in ListModels:', error);
-            throw new Error('Failed to fetch ListModels');
+            return { serverError: error.toString() };
         }
-    });
+    };
+
+    

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

@@ -1,17 +1,14 @@
 'use server';
 
-import { z } from "zod";
-import { actionClient } from "../../../actions/actionClient";
 import { getSDKForCurrentUser } from "../../../getSDKForCurrentUser";
 
-export const getAllNodesAction = actionClient
-    // .schema(listModelsSchema)
-    .action(async ({ parsedInput }) => {
+export const getAllNodesAction = async (): Promise<{data: Node[], serverError?: string}> => {
         try {
             const { node } = await getSDKForCurrentUser();
-            return await node.GetAllNodes();
+            return { data: await node.GetAllNodes() };
         } catch (error) {
             console.error('Error in getAllNodesAction:', error);
-            throw new Error('Failed to fetch nodes');
+            //@ts-ignore
+            return { serverError: error.toString() };
         }
-    });
+    }

package/src/modules/hooks/index.ts

@@ -0,0 +1,5 @@
+
+export * from './lib/handler';
+export * from './lib/Hooks';
+
+import './lib/jobs';

package/src/modules/hooks/lib/Hooks.ts

@@ -0,0 +1,103 @@
+
+type TaskPayload = {
+    timestamp: Date;
+    lastTimestamp?: Date;
+    timezone: string;
+};
+
+type TaskContext = {
+    retriesLeft: number;
+};
+
+type TriggerArgs = {
+    id: string;
+    events: string[];
+    maxDuration?: number; // saniye
+    retries?: number;
+    run: (
+        payload: TaskPayload,
+        tools: { ctx: TaskContext }
+    ) => Promise<void> | void;
+};
+
+export class Hooks {
+    private lastRunTimestamps: Record<string, Date> = {};
+    private triggers: TriggerArgs[] = [];
+
+    public trigger(args: TriggerArgs) {
+        this.triggers.push(args);
+    }
+
+    public async run(hookId: string) {
+        const now = new Date();
+        const lastTimestamp = this.lastRunTimestamps[hookId];
+
+        const payload: TaskPayload = {
+            timestamp: now,
+            lastTimestamp,
+            timezone: "UTC",
+        };
+
+        this.lastRunTimestamps[hookId] = now;
+
+        const context: TaskContext = {
+            retriesLeft: this.triggers.find(hook => hook.id === hookId)?.retries ?? 0,
+        };
+
+        await this.runWithRetry(this.triggers.find(hook => hook.id === hookId)!, payload, context);
+
+
+    }
+
+    private async runWithRetry(
+        trigger: TriggerArgs,
+        payload: TaskPayload,
+        ctx: TaskContext
+    ) {
+        const start = Date.now();
+
+        try {
+            await Promise.race([
+                trigger.run(payload, { ctx }),
+                timeout(trigger.maxDuration ?? 60),
+            ]);
+            log("success", { hookId: trigger.id, time: new Date().toISOString() });
+        } catch (err) {
+            //@ts-ignore
+            log("error", { hookId: trigger.id, error: err });
+
+            if (ctx.retriesLeft > 0) {
+                ctx.retriesLeft -= 1;
+                //@ts-ignore
+                log("warn", { hookId: trigger.id, msg: "Retrying..." });
+                await this.runWithRetry(trigger, payload, ctx);
+            }
+        } finally {
+            const duration = Date.now() - start;
+            //@ts-ignore
+            log("info", { hookId: trigger.id, durationMs: duration });
+        }
+    }
+
+    public toJSON() {
+        return this.triggers.map(trigger => ({
+            id: trigger.id,
+            events: trigger.events,
+            maxDuration: trigger.maxDuration,
+            retries: trigger.retries,
+        }));
+    }
+}
+
+function log(arg0: string, arg1: { hookId: 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 hooks = new Hooks();

package/src/modules/hooks/lib/handler.ts

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

package/src/modules/hooks/lib/jobs/index.ts

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

package/src/modules/hooks/lib/jobs/job1.ts

@@ -0,0 +1,20 @@
+
+import { hooks } from "../Hooks";
+
+hooks.trigger({
+    id: "job1",
+    events: ["event1"],
+    run: async () => {
+        console.log("hello from job 1");
+    },
+});
+
+
+hooks.trigger({
+    id: "job2",
+    events: ["event2"],
+    run: async () => {
+        console.log("hello from job 2");
+    },
+});
+

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

@@ -0,0 +1,10 @@
+import { hooks } from "../Hooks";
+
+
+hooks.trigger({
+    id: "test",
+    events: ["event1"],
+    run: async () => {
+        console.log("test");
+    },
+});

package/src/modules/hooks/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/index.ts

@@ -1,4 +1,8 @@
 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';
+export * from './hooks';

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

@@ -0,0 +1,212 @@
+'use server';
+
+
+import { z, ZodError } from 'zod';
+import { actionClient } from '../../actions/actionClient';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { CreateScheduledJobSchema, DeleteExecutionsSchema, DeleteJobSchema, GetDailyExecutionTrendSchema, GetJobStatsSchema, GetScheduledJobSchema, GetTopFailedJobsSchema, ListAvgExecutionsSchema, ListExecutionsSchema, ListScheduledJobsSchema, QueueJobSchema, UpdateJobSchema } from './schema';
+import { AvgExecution, Execution, ExecutionTrend, FailedJob, JobStats, ScheduledJob } from './types';
+import { AppcondaException } from '../../client';
+import { ActionResult } from '../../lib/types';
+
+export const CreateScheduledJob = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateScheduledJobSchema> }): Promise<{ data?: ScheduledJob, serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.CreateScheduledJob(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in CreateScheduledJob:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const ListScheduledJobs = async (parsedInput: z.infer<typeof ListScheduledJobsSchema>): Promise<{ data?: ScheduledJob[], serverError?: string }> => {
+    try {
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.ListScheduledJobs(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in ListScheduledJobs:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const GetScheduledJob = async (parsedInput: z.infer<typeof GetScheduledJobSchema>): Promise<{ data?: ScheduledJob, serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.GetScheduledJob(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetScheduledJob:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const ListExecutions = async (parsedInput: z.infer<typeof ListExecutionsSchema>): Promise<{ data?: Execution[], serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.ListExecutions(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in ListExecutions:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const ListAvgExecutions = async (parsedInput: z.infer<typeof ListAvgExecutionsSchema>): Promise<{ data?: AvgExecution[], serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.ListAvgExecutions(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in ListAvgExecutions:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const UpdateJob = async (params: z.infer<typeof UpdateJobSchema>): Promise<ActionResult<ScheduledJob>> => {
+    try {
+        console.log('params', params);
+        const parsedInput = UpdateJobSchema.parse(params);
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.UpdateJob(parsedInput) };
+
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            return { serverError: error.message };
+        }
+        if (error instanceof ZodError) {
+            return { validationError: error.toString() };
+        }
+        console.error('Error in UpdateJob:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const GetDailyExecutionTrend = async (parsedInput: z.infer<typeof GetDailyExecutionTrendSchema>): Promise<{ data?: ExecutionTrend[], serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.GetDailyExecutionTrend(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetDailyExecutionTrend:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+
+
+export const GetTopFailedJobs = async (parsedInput: z.infer<typeof GetTopFailedJobsSchema>): Promise<{ data?: FailedJob[], serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        //@ts-ignore
+        return { data: await scheduledJob.GetTopFailedJobs(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetTopFailedJobs:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const GetJobStats = async (parsedInput: z.infer<typeof GetJobStatsSchema>): Promise<{ data?: JobStats, serverError?: string }> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.GetJobStats(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in GetJobStats:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const DeleteJob = async (parsedInput: z.infer<typeof DeleteJobSchema>): Promise<ActionResult<void>> => {
+    try {
+        const { scheduledJob } = await getSDKForCurrentUser();
+        await scheduledJob.DeleteJob(parsedInput);
+        return {};
+    } catch (error) {
+        console.error('Error in DeleteJob:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const ListJobsWithStats = async () => {
+    try {
+
+        const jobs = await ListScheduledJobs({});
+        const avg = await ListAvgExecutions({});
+
+        // Merge jobs with average execution data
+        const mergedJobs = jobs?.data?.map(job => {
+            const jobAvg = avg?.data?.find(a => a.scheduledJobId === job.id);
+            return {
+                ...job,
+                totalExecutions: jobAvg?.totalExecutions || 0,
+                activeDays: jobAvg?.activeDays || 0,
+                avgExecutionsPerDay: jobAvg?.avgExecutionsPerDay || 0,
+                completed: jobAvg?.completed || 0,
+                failed: jobAvg?.failed || 0,
+                queued: jobAvg?.queued || 0,
+            };
+        }) || [];
+
+        return { data: mergedJobs };
+
+    } catch (error) {
+        console.error('Error in ListJobsWithStats:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+export const GetJobMetrics = async () => {
+    try {
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return await scheduledJob.GetJobMetrics();
+    } catch (error) {
+        console.error('Error in GetJobMetrics:', error);
+        throw new Error(error.toString());
+    }
+};
+
+export const QueueJob = async (parsedInput: z.infer<typeof QueueJobSchema>): Promise<boolean> => {
+    try {
+        const { scheduledJob } = await getSDKForCurrentUser();
+        await scheduledJob.QueueJob(parsedInput);
+        return true;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            console.error('Error in QueueJob:', error.message);
+
+        }
+        return false;
+    }
+};
+
+export const DeleteExecutions = async ( parsedInput: z.infer<typeof DeleteExecutionsSchema> ): Promise<{data?: void, serverError?: string}> => {
+    try {
+
+        const { scheduledJob } = await getSDKForCurrentUser();
+        return { data: await scheduledJob.DeleteExecutions(parsedInput) };
+
+    } catch (error) {
+        console.error('Error in DeleteExecutions:', error);
+        return { serverError: error.toString() };
+    }
+};
+
+
+
+
+
+
+
+
+
+

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';