@appconda/nextjs 1.0.138 → 1.0.140

package/src/modules/task/action.ts

@@ -1,29 +1,23 @@
 'use server';
 
 
-import { actionClient } from '../../actions/actionClient';
+import { z } from 'zod';
 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();
+export const CreateProject = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateProjectSchema> }): Promise<{data?: Project, serverError?: string}> => {
+    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');
+            return { serverError: error.toString() };
         }
-    });
+    };
 
-    export const ListProjects = actionClient
-    .schema(ListProjectsSchema)
-    .action(async ({ parsedInput }): Promise<Project[]> => {
+    export const ListProjects = async ({ parsedInput }: { parsedInput: z.infer<typeof ListProjectsSchema> }): Promise<{data?: Project[], serverError?: string}> => {
         try {
 
             const { task } = await getSDKForCurrentUser();
@@ -31,145 +25,129 @@ export const CreateProject = actionClient
 
         } catch (error) {
             console.error('Error in ListProjects:', error);
-            throw new Error('Failed to fetch ListProjects');
+            return { serverError: error.toString() };
         }
-    });
+    };
 
-export const CreateTaskList = actionClient
-    .schema(CreateTaskListSchema)
-    .action(async ({ parsedInput }): Promise<TaskList> => {
-        try {
+export const CreateTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.CreateTaskList(parsedInput);
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.CreateTaskList(parsedInput) };
 
         } catch (error) {
             console.error('Error in CreateTaskList:', error);
-            throw new Error('Failed to fetch CreateTaskList');
+            return { serverError: error.toString() };
         }
-    });
+    };
 
-export const GetTaskList = actionClient
-    .schema(GetTaskListSchema)
-    .action(async ({ parsedInput }): Promise<TaskList> => {
-        try {
+export const GetTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof GetTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.GetTaskList(parsedInput);
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.GetTaskList(parsedInput) };
 
-        } catch (error) {
-            console.error('Error in GetTaskList:', error);
-            throw new Error('Failed to fetch GetTaskList');
-        }
-    });
+    } catch (error) {
+        console.error('Error in GetTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-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 ListTaskLists = async (): Promise<{data?: TaskList[], serverError?: string}> => {
+    try {
 
-export const UpdateTaskList = actionClient
-    .schema(UpdateTaskListSchema)
-    .action(async ({ parsedInput }): Promise<TaskList> => {
-        try {
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.ListTaskLists() };
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.UpdateTaskList(parsedInput);
+    } catch (error) {
+        console.error('Error in ListTaskLists:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-        } catch (error) {
-            console.error('Error in UpdateTaskList:', error);
-            throw new Error('Failed to fetch UpdateTaskList');
-        }
-    });
+export const UpdateTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof UpdateTaskListSchema> }): Promise<{data?: TaskList, serverError?: string}> => {
+    try {
 
-export const DeleteTaskList = actionClient
-    .schema(DeleteTaskListSchema)
-    .action(async ({ parsedInput }): Promise<void> => {
-        try {
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.UpdateTaskList(parsedInput) };
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.DeleteTaskList(parsedInput);
+    } catch (error) {
+        console.error('Error in UpdateTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-        } 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 {
+export const DeleteTaskList = async ({ parsedInput }: { parsedInput: z.infer<typeof DeleteTaskListSchema> }): Promise<{data?: void, serverError?: string}> => {
+    try {
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.CreateSprint(parsedInput);
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.DeleteTaskList(parsedInput) };
 
-        } catch (error) {
-            console.error('Error in CreateSprint:', error);
-            throw new Error('Failed to fetch CreateSprint');
-        }
-    });
+    } catch (error) {
+        console.error('Error in DeleteTaskList:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-export const GetSprint = actionClient
-    .schema(GetSprintSchema)
-    .action(async ({ parsedInput }): Promise<Sprint> => {
-        try {
+export const CreateSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof CreateSprintSchema> }): Promise<{data?: Sprint, serverError?: string}> => {
+    try {
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.GetSprint(parsedInput);
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.CreateSprint(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 {
+    } catch (error) {
+        console.error('Error in CreateSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.ListSprints();
+export const GetSprint = async ({ parsedInput }: { parsedInput: z.infer<typeof GetSprintSchema> }): Promise<{data?: Sprint, serverError?: string}> => {
+    try {
 
-        } 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 { data: await task.GetSprint(parsedInput) };
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.UpdateSprint(parsedInput);
+    } catch (error) {
+        console.error('Error in GetSprint:', error);
+        return { serverError: error.toString() };
+    }
+};
 
-        } 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 {
+export const ListSprints = async ({ parsedInput }: { parsedInput: z.infer<typeof ListSprintsSchema> }): Promise<{data?: Sprint[], serverError?: string}> => {
+    try {
 
-            const { task } = await getSDKForCurrentUser();
-            return await task.DeleteSprint(parsedInput);
+        const { task } = await getSDKForCurrentUser();
+        return { data: await task.ListSprints() };
 
-        } catch (error) {
-            console.error('Error in DeleteSprint:', error);
-            throw new Error('Failed to fetch DeleteSprint');
-        }
-    });
+    } 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() };
+    }
+};
+    

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

@@ -1,21 +0,0 @@
- 'use server';
-
-import { z } from "zod";
-
-import { UpdateJobSchema } from "./schema";
-import { getSDKForCurrentUser } from "../../getSDKForCurrentUser";
-
-
- export const UpdateJob = async (params: z.infer<typeof UpdateJobSchema>) => {
-        try {
-            const parsedInput = UpdateJobSchema.parse(params);
-            const { scheduledJob } = await getSDKForCurrentUser();
-            return await scheduledJob.UpdateJob(parsedInput);
-
-        } catch (error) {
-            console.error('Error in UpdateJob:', error);
-            return {
-                serverError: error.toString()
-            }
-        }
-    }