@appconda/nextjs 1.0.161 → 1.1.3

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

package/src/modules/task/schema.ts

@@ -0,0 +1,53 @@
+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()
+});

package/src/modules/task/service.ts

@@ -0,0 +1,62 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateProjectSchema, CreateSprintSchema, CreateTaskListSchema, 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);
+    }
+
+
+}

package/src/modules/task/types.ts

@@ -0,0 +1,89 @@
+
+export type TaskList = {
+    id: string;
+    name: string;
+    description: string;
+}
+
+export type Sprint = {
+    id: string;
+    name: string;
+    description: string;
+}
+
+
+export type Project = {
+    id: string;
+    tenantId: string;
+    picture?: string;
+    ownerId: string;
+    title: string;
+    web?: string;
+    createdDate: Date;
+    updatedDate: Date;
+    description?: string;
+    starred: number;
+    archived: boolean;
+    defaultView: boolean;
+    itemName: string;
+    itemsName: string;
+    projectType: number;
+    commentAll: number;
+    commitsVisibility: number;
+    inviteAll: boolean;
+    projectColor?: string;
+    viewTitle?: string;
+    position?: number;
+    tasks: Task[];
+}
+export interface Task {
+    id: string;
+    projectId: string;
+    project: Project;
+    milestoneId?: string;
+    milestone?: Milestone;
+    sprintId?: string;
+    sprint?: Sprint;
+    taskType: string;
+    creator: string;
+    secondId: number;
+    title: string;
+    description?: string;
+    lastPicture?: string;
+    lastPictureExternalUrl?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deadline?: Date;
+    archived: boolean;
+    color?: string;
+    estimated?: string;
+    timeTracked?: string;
+    isPublic: boolean;
+    state: number;
+    coverWidth?: number;
+    coverHeight?: number;
+    checklist?: string;
+    comments: number;
+    publicComments: number;
+    likes: number;
+    attachments: number;
+    commits: number;
+    supportTickets: number;
+    value?: number;
+    points?: number;
+    pointsDone?: number;
+    position?: number;
+}
+
+export type Milestone = {
+    id: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    archived: boolean;
+    complete: boolean;
+    deadline: Date;
+    color?: string;
+    position: number;
+    Task: Task[];
+}

package/src/modules/tenant/actions.ts

@@ -0,0 +1,46 @@
+'use server';
+import { z } from "zod";
+import { actionClient } from "../../actions/actionClient";
+import { getSDKForCurrentUser } from "../../getSDKForCurrentUser";
+
+const getTenantActionSchema = z.object({
+    tenantId: z.string()
+});
+
+export const getTenantAction = actionClient
+    .schema(getTenantActionSchema)
+    .action(async ({ parsedInput }) => {
+        const { tenantId } = parsedInput;
+        const { tenants } = await getSDKForCurrentUser();
+        return await tenants.get(tenantId);
+    });
+
+
+
+const listUserTenantsScheema = z.object({
+    userId: z.string()
+});
+
+export const listUserTenantsAction = actionClient
+    .schema(listUserTenantsScheema)
+    .action(async ({ parsedInput }) => {
+        const { userId } = parsedInput;
+        const { tenants } = await getSDKForCurrentUser();
+        return await tenants.listUserTenants(userId);
+    });
+
+
+const createTenantScheema = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string()
+});
+
+export const createTenantAction = actionClient
+    .schema(createTenantScheema)
+    .action(async ({ parsedInput }) => {
+        const { id, name, slug } = parsedInput;
+        const { tenants } = await getSDKForCurrentUser();
+        //@ts-ignore
+        return await tenants.create({ $id: id, name: name, slug: slug });
+    });

package/src/modules/tenant/index.ts

@@ -0,0 +1,3 @@
+export * from "./tenant";
+export * from "./types";
+export * from "./actions";

package/src/{services → modules/tenant}/tenant.ts

@@ -1,5 +1,5 @@
-import { AppcondaException, Client, Models, Payload } from "../client";
-import { ServiceClient } from "../service-client";
+import { AppcondaException, Client, Models, Payload } from "../../client";
+import { ServiceClient } from "../../service-client";
 
 export type TenantSimple = {
     id: string;
@@ -11,9 +11,8 @@ export type TenantSimple = {
     active: boolean;
   };
 
-export class Tenant extends ServiceClient{
+export class TenantService extends ServiceClient{
   
-
     public getServiceName(): string {
         return 'com.appconda.service.tenant';
     }

package/src/modules/tenant/types.ts

@@ -0,0 +1,12 @@
+
+export type Tenant = {
+    id: string
+    createdAt: Date
+    updatedAt: Date
+    slug: string
+    name: string
+    icon: string | null
+    subscriptionId: string | null
+    active: boolean
+    deactivatedReason: string | null
+} 

package/tsconfig.json

@@ -6,7 +6,8 @@
     "allowSyntheticDefaultImports": true,
     "declaration": true,
     "esModuleInterop": true,
-    "inlineSourceMap": false,
+    "inlineSourceMap": true,
+    "inlineSources": true,
     "lib": ["ESNext", "DOM"],
     "listEmittedFiles": false,
     "listFiles": false,
@@ -18,6 +19,8 @@
     "traceResolution": false,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
+    "strictNullChecks": true,
+    "exactOptionalPropertyTypes": true,
     "outDir": "./dist",
     "paths": {
       "next-safe-action": ["./node_modules/next-safe-action/index.d.ts"]

package/dist/actions/nodes.d.ts

@@ -1,4 +0,0 @@
-export declare const getAllNodesAction: import("next-safe-action").SafeActionFn<string, undefined, readonly [], {
-    formErrors: string[];
-    fieldErrors: {};
-}, readonly [], any[]>;

package/dist/actions/nodes.js

@@ -1,15 +0,0 @@
-'use server';
-import { actionClient } from "./actionClient";
-import { getSDKForCurrentUser } from '../getSDKForCurrentUser';
-export const getAllNodesAction = actionClient
-    // .schema(listModelsSchema)
-    .action(async ({ parsedInput }) => {
-    try {
-        const { node } = await getSDKForCurrentUser();
-        return await node.GetAllNodes();
-    }
-    catch (error) {
-        console.error('Error in getAllNodesAction:', error);
-        throw new Error('Failed to fetch nodes');
-    }
-});

package/dist/enums/authentication-factor.d.ts

@@ -1,6 +0,0 @@
-export declare enum AuthenticationFactor {
-    Email = "email",
-    Phone = "phone",
-    Totp = "totp",
-    Recoverycode = "recoverycode"
-}

package/dist/enums/authentication-factor.js

@@ -1,7 +0,0 @@
-export var AuthenticationFactor;
-(function (AuthenticationFactor) {
-    AuthenticationFactor["Email"] = "email";
-    AuthenticationFactor["Phone"] = "phone";
-    AuthenticationFactor["Totp"] = "totp";
-    AuthenticationFactor["Recoverycode"] = "recoverycode";
-})(AuthenticationFactor || (AuthenticationFactor = {}));

package/dist/enums/authenticator-type.d.ts

@@ -1,3 +0,0 @@
-export declare enum AuthenticatorType {
-    Totp = "totp"
-}

package/dist/enums/authenticator-type.js

@@ -1,4 +0,0 @@
-export var AuthenticatorType;
-(function (AuthenticatorType) {
-    AuthenticatorType["Totp"] = "totp";
-})(AuthenticatorType || (AuthenticatorType = {}));

package/dist/enums/o-auth-provider.d.ts

@@ -1,41 +0,0 @@
-export declare enum OAuthProvider {
-    Amazon = "amazon",
-    Apple = "apple",
-    Auth0 = "auth0",
-    Authentik = "authentik",
-    Autodesk = "autodesk",
-    Bitbucket = "bitbucket",
-    Bitly = "bitly",
-    Box = "box",
-    Dailymotion = "dailymotion",
-    Discord = "discord",
-    Disqus = "disqus",
-    Dropbox = "dropbox",
-    Etsy = "etsy",
-    Facebook = "facebook",
-    Github = "github",
-    Gitlab = "gitlab",
-    Google = "google",
-    Linkedin = "linkedin",
-    Microsoft = "microsoft",
-    Notion = "notion",
-    Oidc = "oidc",
-    Okta = "okta",
-    Paypal = "paypal",
-    PaypalSandbox = "paypalSandbox",
-    Podio = "podio",
-    Salesforce = "salesforce",
-    Slack = "slack",
-    Spotify = "spotify",
-    Stripe = "stripe",
-    Tradeshift = "tradeshift",
-    TradeshiftBox = "tradeshiftBox",
-    Twitch = "twitch",
-    Wordpress = "wordpress",
-    Yahoo = "yahoo",
-    Yammer = "yammer",
-    Yandex = "yandex",
-    Zoho = "zoho",
-    Zoom = "zoom",
-    Mock = "mock"
-}

package/dist/enums/o-auth-provider.js

@@ -1,42 +0,0 @@
-export var OAuthProvider;
-(function (OAuthProvider) {
-    OAuthProvider["Amazon"] = "amazon";
-    OAuthProvider["Apple"] = "apple";
-    OAuthProvider["Auth0"] = "auth0";
-    OAuthProvider["Authentik"] = "authentik";
-    OAuthProvider["Autodesk"] = "autodesk";
-    OAuthProvider["Bitbucket"] = "bitbucket";
-    OAuthProvider["Bitly"] = "bitly";
-    OAuthProvider["Box"] = "box";
-    OAuthProvider["Dailymotion"] = "dailymotion";
-    OAuthProvider["Discord"] = "discord";
-    OAuthProvider["Disqus"] = "disqus";
-    OAuthProvider["Dropbox"] = "dropbox";
-    OAuthProvider["Etsy"] = "etsy";
-    OAuthProvider["Facebook"] = "facebook";
-    OAuthProvider["Github"] = "github";
-    OAuthProvider["Gitlab"] = "gitlab";
-    OAuthProvider["Google"] = "google";
-    OAuthProvider["Linkedin"] = "linkedin";
-    OAuthProvider["Microsoft"] = "microsoft";
-    OAuthProvider["Notion"] = "notion";
-    OAuthProvider["Oidc"] = "oidc";
-    OAuthProvider["Okta"] = "okta";
-    OAuthProvider["Paypal"] = "paypal";
-    OAuthProvider["PaypalSandbox"] = "paypalSandbox";
-    OAuthProvider["Podio"] = "podio";
-    OAuthProvider["Salesforce"] = "salesforce";
-    OAuthProvider["Slack"] = "slack";
-    OAuthProvider["Spotify"] = "spotify";
-    OAuthProvider["Stripe"] = "stripe";
-    OAuthProvider["Tradeshift"] = "tradeshift";
-    OAuthProvider["TradeshiftBox"] = "tradeshiftBox";
-    OAuthProvider["Twitch"] = "twitch";
-    OAuthProvider["Wordpress"] = "wordpress";
-    OAuthProvider["Yahoo"] = "yahoo";
-    OAuthProvider["Yammer"] = "yammer";
-    OAuthProvider["Yandex"] = "yandex";
-    OAuthProvider["Zoho"] = "zoho";
-    OAuthProvider["Zoom"] = "zoom";
-    OAuthProvider["Mock"] = "mock";
-})(OAuthProvider || (OAuthProvider = {}));