@appconda/sdk 1.0.194 → 1.0.409

package/src/modules/agent/service.ts

@@ -0,0 +1,34 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateAgentSchema, GetAgentSchema, ListModelsSchema } from "./schema";
+import { Agent, AIModel } from "./types";
+
+
+export class AgentService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.agent';
+    }
+
+    public async CreateAgent(payload: z.infer<typeof CreateAgentSchema>): Promise<Agent> {
+        return await this.actionCall('CreateAgent', payload);
+    }
+
+    public async GetAgent(payload: z.infer<typeof GetAgentSchema>): Promise<Agent> {
+        return await this.actionCall('GetAgent', payload);
+    }
+
+    public async ListAgents(): Promise<Agent[]> {
+        return await this.actionCall('ListAgents', {});
+    }
+
+    public async ListModelProviders(): Promise<Agent[]> {
+        return await this.actionCall('ListModelProviders', {});
+    }
+
+    public async ListModels(payload: z.infer<typeof ListModelsSchema>): Promise<AIModel[]> {
+        return await this.actionCall('ListModels', payload);
+    }
+
+
+}

package/src/modules/agent/types.ts

@@ -0,0 +1,15 @@
+
+export type Agent = {
+    id: string;
+    agent_key: string;
+    name: string;
+    description: string;
+    aiModelId: string;
+}
+
+
+export type AIModel = {
+    id: string;
+    name:string;
+}
+

package/src/modules/ai/index.ts

@@ -0,0 +1 @@
+export * from './node';

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

@@ -0,0 +1,14 @@
+'use server';
+
+import { getSDKForCurrentUser } from "../../../getSDKForCurrentUser";
+
+export const getAllNodesAction = async (): Promise<{data: Node[], serverError?: string}> => {
+        try {
+            const { node } = await getSDKForCurrentUser();
+            return { data: await node.GetAllNodes() };
+        } catch (error) {
+            console.error('Error in getAllNodesAction:', error);
+            //@ts-ignore
+            return { serverError: error.toString() };
+        }
+    }

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

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './service';

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

@@ -0,0 +1,18 @@
+import { Payload } from "../../../client";
+import { ServiceClient } from "../../../service-client";
+
+
+
+
+export class Node extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.node';
+    }
+
+    // @Cache()
+    public async GetAllNodes(isPublic?: boolean): Promise<any[]> {
+        const payload: Payload = {};
+        return await this.actionCall('GetAllNodes', payload);
+    }
+
+}

package/src/modules/bpm/index.ts

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

package/src/modules/bpm/schema.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+export const CreateProcessModelSchema = z.object({
+    tenantId: z.string(),
+    name: z.string(),
+});
+
+ 
+export const UpdateProcessModelSchema = z.object({
+    tenantId: z.string(),
+    id: z.string(),
+    bpmn: z.string(),
+    svg: z.string()
+});
+
+export const ListProcessModelsSchema = z.object({
+    tenantId: z.string()
+});
+
+export const DeleteProcessModelSchema = z.object({
+    tenantId: z.string(),
+    id: z.string()
+});

package/src/modules/bpm/service.ts

@@ -0,0 +1,28 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateProcessModelSchema, DeleteProcessModelSchema, ListProcessModelsSchema, UpdateProcessModelSchema } from "./schema";
+import { TProcessModel } from "./types";
+
+
+export class BpmService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.bpm';
+    }
+
+    public async CreateProcessModel(payload: z.infer<typeof CreateProcessModelSchema>): Promise<TProcessModel> {
+        return await this.actionCall('process-model', 'CreateProcessModel', payload);
+    }
+
+    public async UpdateProcessModel(payload: z.infer<typeof UpdateProcessModelSchema>): Promise<TProcessModel> {
+        return await this.actionCall('process-model', 'UpdateProcessModel', payload);
+    }
+
+    public async ListProcessModels(payload: z.infer<typeof ListProcessModelsSchema>): Promise<TProcessModel[]> {
+        return await this.actionCall('process-model', 'ListProcessModels', payload);
+    }
+
+    public async DeleteProcessModel(payload: z.infer<typeof DeleteProcessModelSchema>): Promise<TProcessModel> {
+        return await this.actionCall('process-model', 'DeleteProcessModel', payload);
+    }
+}

package/src/modules/bpm/types.ts

@@ -0,0 +1,11 @@
+
+
+export type TProcessModel = {
+    id: string;
+    name: string;
+    description: string;
+    status: string;
+    occupation: string;
+    createdAt: string;
+    updatedAt: string;
+}

package/src/modules/builder/action.ts

@@ -0,0 +1,234 @@
+'use server';
+
+import { z } from 'zod';
+import { AppcondaException } from '../../client';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { CreateAppSchema, CreateModuleSchema, CreatePageSchema, CreatePageSchemaSchema, GetAppSchema, GetPageBySlugSchema, GetPageSchemaSchema, ListAppsSchema, ListModulesSchema, ListPagesSchema, UpdateAppSchema, UpdateEditorConfigSchema, UpdatePageSchemaSchema } from './schema';
+import { Config } from './types';
+import { getSDKForService } from '../../getSDKForService';
+
+export const CreateApp = async (parsedInput: z.infer<typeof CreateAppSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const app = await builder.CreateApp(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const UpdateApp = async (parsedInput: z.infer<typeof UpdateAppSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const app = await builder.UpdateApp(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const UpdateEditorConfig = async (parsedInput: z.infer<typeof UpdateEditorConfigSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const app = await builder.UpdateEditorConfig(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const GetEditorConfig = async () => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const config = await builder.GetEditorConfig();
+        return config;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const GetApp = async (parsedInput: z.infer<typeof GetAppSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const app = await builder.GetApp(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListApps = async (parsedInput: z.infer<typeof ListAppsSchema>) => {
+    try {
+        
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const apps = await builder.ListApps(parsedInput);
+        return apps;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListBuilderProjects = async (parsedInput: z.infer<typeof ListAppsSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const apps = await builder.ListProjects(parsedInput);
+        return apps;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const CreatePage = async (parsedInput: z.infer<typeof CreatePageSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const page = await builder.CreatePage(parsedInput);
+        return page;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListPages = async (parsedInput: z.infer<typeof ListPagesSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const pages = await builder.ListPages(parsedInput);
+        return pages;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const CreatePageSchemaAction = async (parsedInput: z.infer<typeof CreatePageSchemaSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const pageSchema = await builder.CreatePageSchema(parsedInput);
+        return pageSchema;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const UpdatePageSchema = async (parsedInput: z.infer<typeof UpdatePageSchemaSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const pageSchema = await builder.UpdatePageSchema(parsedInput);
+        return pageSchema;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};  
+
+export const GetPageSchema = async (parsedInput: z.infer<typeof GetPageSchemaSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const pageSchema = await builder.GetPageSchema(parsedInput);
+        return pageSchema;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListModules = async (parsedInput: z.infer<typeof ListModulesSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const modules = await builder.ListModules(parsedInput);
+        return modules;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const CreateModule = async (parsedInput: z.infer<typeof CreateModuleSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const module = await builder.CreateModule(parsedInput);
+        return module;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const GetPageBySlug = async (parsedInput: z.infer<typeof GetPageBySlugSchema>) => {
+    try {
+        const { builder } = await getSDKForService();
+        //@ts-ignore
+        const page = await builder.GetPageBySlug(parsedInput);
+        return page;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};

package/src/modules/builder/index.ts

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

package/src/modules/builder/schema.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+export const CreateAppSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    ownerId: z.string(),
+    title: z.string(),
+    description: z.string().optional()
+});
+
+export const UpdateAppSchema = z.object({
+    id: z.string(),
+    schema: z.any(),
+    config: z.any()
+});
+
+export const GetAppSchema = z.object({
+    id: z.string()
+});
+
+export const ListAppsSchema = z.object({
+    tenantId: z.string()
+});
+
+export const CreatePageSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    appId: z.string(),
+    moduleId: z.string(),
+    slug: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    parentId: z.string().optional(),
+    isFolder: z.boolean().default(false)
+});
+
+export const CreateWorkflowSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    appId: z.string(),
+    moduleId: z.string(),
+    slug: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    parentId: z.string().optional(),
+    isFolder: z.boolean().default(false)
+});
+
+export const CreatePageSchemaSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    appId: z.string(),
+    pageId: z.string(),
+    schema: z.string()
+});
+
+export const ListPagesSchema = z.object({
+    tenantId: z.string(),
+    appId: z.string(),
+    moduleId: z.string()
+});
+
+export const UpdatePageSchemaSchema = z.object({
+    id: z.string(),
+    schema: z.string()
+});
+
+export const GetPageSchemaSchema = z.object({
+    id: z.string()
+});
+
+export const CreateModuleSchema = z.object({
+    id: z.string().optional(),
+    tenantId: z.string(),
+    appId: z.string(),
+    name: z.string(),
+    description: z.string().optional()
+});
+
+export const ListModulesSchema = z.object({
+    tenantId: z.string(),
+    appId: z.string()
+});
+
+export const UpdateEditorConfigSchema = z.object({
+    extensions: z.array(z.object({
+        id: z.string()
+    })).optional()
+});
+    
+
+export const GetPageBySlugSchema = z.object({
+    appId: z.string(),
+    slug: z.string()
+});

package/src/modules/builder/service.ts

@@ -0,0 +1,74 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { CreateAppSchema, CreateModuleSchema, CreatePageSchema, CreatePageSchemaSchema, GetAppSchema, GetPageBySlugSchema, GetPageSchemaSchema, ListAppsSchema, ListModulesSchema, ListPagesSchema, UpdateAppSchema, UpdateEditorConfigSchema, UpdatePageSchemaSchema } from "./schema";
+import { App, Config, Module, Page, PageSchema } from "./types";
+
+
+export class BuilderService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.builder';
+    }
+
+    public async CreateApp(payload: z.infer<typeof CreateAppSchema>): Promise<App> {
+        return await this.actionCall('app', 'CreateApp', payload);
+    }
+
+    public async UpdateApp(payload: z.infer<typeof UpdateAppSchema>): Promise<App> {
+        return await this.actionCall('app', 'UpdateApp', payload);
+    }
+
+    public async UpdateEditorConfig(payload: z.infer<typeof UpdateEditorConfigSchema>): Promise<App> {
+        return await this.actionCall('editor', 'UpdateEditorConfig', {config : payload});
+    }
+
+    public async GetEditorConfig(): Promise<Config> {
+        return await this.actionCall('editor', 'GetEditorConfig', {});
+    }
+
+    public async GetApp(payload: z.infer<typeof GetAppSchema>): Promise<App> {
+        return await this.actionCall('app', 'GetApp', payload);
+    }
+
+    public async ListApps(payload: z.infer<typeof ListAppsSchema>): Promise<App[]> {
+        return this.actionCall('app', 'ListApps', payload);
+    }
+
+    public async ListProjects(payload: z.infer<typeof ListAppsSchema>): Promise<App[]> {
+       
+        return this.actionCall('project', 'ListProjects', payload);
+    }
+
+    public async CreatePage(payload: z.infer<typeof CreatePageSchema>): Promise<Page> {
+        return await this.actionCall('page', 'CreatePage', payload);
+    }
+
+    public async ListPages(payload: z.infer<typeof ListPagesSchema>): Promise<Page[]> {
+        return this.actionCall('page', 'ListPages', payload);
+    }
+
+    public async CreatePageSchema(payload: z.infer<typeof CreatePageSchemaSchema>): Promise<PageSchema> {
+        return await this.actionCall('page', 'CreatePageSchema', payload);
+    }
+
+    public async UpdatePageSchema(payload: z.infer<typeof UpdatePageSchemaSchema>): Promise<PageSchema> {
+        return await this.actionCall('page', 'UpdatePageSchema', payload);
+    }
+
+    public async GetPageSchema(payload: z.infer<typeof GetPageSchemaSchema>): Promise<PageSchema> {
+        return await this.actionCall('page', 'GetPageSchema', payload);
+    }
+
+    public async CreateModule(payload: z.infer<typeof CreateModuleSchema>): Promise<Module> {
+        return await this.actionCall('module', 'CreateModule', payload);
+    }
+
+    public async ListModules(payload: z.infer<typeof ListModulesSchema>): Promise<Module[]> {
+        return this.actionCall('module', 'ListModules', payload);
+    }
+
+    public async GetPageBySlug(payload: z.infer<typeof GetPageBySlugSchema>): Promise<Page> {
+        return this.actionCall('publish', 'GetPageBySlug', payload);
+    }
+
+}

package/src/modules/builder/types.ts

@@ -0,0 +1,68 @@
+
+export type AppSchema = {
+    modules: Module[]
+}
+export type App = {
+    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;
+    schema?: AppSchema;
+}
+
+export type Page = {
+    id: string;
+    tenantId: string;
+    appId: string;
+    moduleId: string;
+    title: string;
+    description?: string;
+    createdDate: Date;
+    updatedDate: Date;
+    parentId?: string;
+    isFolder?: boolean;
+    schema?: any;
+}
+
+export type PageSchema = {
+    id: string;
+    tenantId: string;
+    pageId: string;
+    schema: string;
+}
+
+export type Module = {
+    id: string;
+    tenantId: string;
+    appId: string;
+    name: string;
+    description?: string;
+    createdDate: Date;
+    updatedDate: Date;
+    pages: Page[];
+}
+
+export type Extensions = {
+    id: string;
+}
+
+export type Config = {
+    extensions: Extensions[];
+}