@appconda/sdk 1.0.193 → 1.0.409

package/src/modules/emploid/types.ts

@@ -0,0 +1,132 @@
+
+export type TEmploid = {
+    id: string;
+    name: string;
+    description: string;
+    status: string;
+    occupation: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export type TPaginatedEmploidsResult = {
+    emploids: TEmploid[];
+    totalCount: number;
+    hasMore: boolean;
+    nextCursor?: string;
+};
+
+export type TScope = {
+    id: string;
+    emploidId: string;
+    name: string;
+    description: string;
+}
+
+export type TOccupation = {
+    id: string;
+    name: string;
+    description: string;
+}
+
+export type TJobDefinition = {
+    id: string;
+    emploidId: string;
+    scopeId: string;
+    name: string;
+    description: string;
+    category: string;
+    priority: string;
+    status: string;
+}
+
+export type TCompetency = {
+    id: string;
+    emploidId: string;
+    scopeId: string;
+    jobDefinitionId: string;
+    name: string;
+    description: string;
+}
+
+export type TAgentFlow = {
+    id: string;
+    name: string;
+    description: string;
+}
+
+export type TExtension = {
+    id: string;
+    config: any;
+}
+
+export type TAssistant = {
+    id: string;
+    alias: string;
+    name: string;
+    description: string;
+    prompt: string;
+}
+
+export type TWorker = {
+    id: string;
+    emploidId: string;
+    name: string;
+    description: string;
+}
+
+export type TInput = {
+    id: string;
+    emploidId: string;
+    competencyId: string;
+    name: string;
+    description: string;
+    type: string;
+}
+
+export type TTeam = {
+    id: string;
+    alias: string;
+    name: string;
+    description: string;
+}
+
+export type TChat = {
+    id: string;
+    createdAt: string;
+    title: string;
+    userId: string;
+    visibility: string;
+    lastContext: any;
+}
+
+ 
+export type TDocument = {
+    id: string;
+    createdAt: string;
+    title: string;
+    content?: string;
+    kind: string;
+    userId: string;
+}
+
+export type TStreamId = {
+    id: string;
+    chatId: string;
+    createdAt: string;
+}
+
+export type TSkill = {
+    id: string;
+    name: string;
+    description: string;
+    graph: string;
+}
+
+export type TInstruction = {
+    id: string;
+    emploidId: string;
+    content: string;
+    type: string;
+    active: boolean;
+}

package/src/modules/google/action.ts

@@ -0,0 +1,54 @@
+'use server';
+
+import { z } from 'zod';
+import { AppcondaException } from '../../client';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { ListSpreadSheetsSchema, ListWorkbookColumnsSchema, ListWorkbooksSchema } from './schema';
+
+
+
+export const ListSpreadSheets = async (parsedInput: z.infer<typeof ListSpreadSheetsSchema>) => {
+    try {
+        const { google } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await google.ListSpreadSheets(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListWorkbooks = async (parsedInput: z.infer<typeof ListWorkbooksSchema>) => {
+    try {
+        const { google } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await google.ListWorkbooks(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListWorkbookColumns = async (parsedInput: z.infer<typeof ListWorkbookColumnsSchema>) => {
+    try {
+        const { google } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await google.ListWorkbookColumns(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+

package/src/modules/google/index.ts

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

package/src/modules/google/schema.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+
+
+export const ListSpreadSheetsSchema = z.object({
+   dataSourceId: z.string()
+});
+
+export const ListWorkbooksSchema = z.object({
+   dataSourceId: z.string(),
+   spreadsheetId: z.string()
+});
+
+export const ListWorkbookColumnsSchema = z.object({
+   dataSourceId: z.string(),
+   spreadsheetId: z.string(),
+   sheetName: z.string()
+});
+

package/src/modules/google/service.ts

@@ -0,0 +1,23 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { ListSpreadSheetsSchema, ListWorkbookColumnsSchema, ListWorkbooksSchema } from "./schema";
+import { TSpreadSheet, TSpreadSheetColumn } from "./types";
+
+export class GoogleService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.google';
+    }
+
+    public async ListSpreadSheets(payload: z.infer<typeof ListSpreadSheetsSchema>): Promise<TSpreadSheet[]> {
+        return await this.actionCall('spreadsheets', 'ListSpreadSheets', payload);
+    }
+
+    public async ListWorkbooks(payload: z.infer<typeof ListWorkbooksSchema>): Promise<TSpreadSheet[]> {
+        return await this.actionCall('spreadsheets', 'ListWorkbooks', payload);
+    }
+
+    public async ListWorkbookColumns(payload: z.infer<typeof ListWorkbookColumnsSchema>): Promise<TSpreadSheetColumn[]> {
+        return await this.actionCall('spreadsheets', 'ListWorkbookColumns', payload);
+    }
+}

package/src/modules/google/types.ts

@@ -0,0 +1,15 @@
+
+
+export type TSpreadSheet = {
+    id: string;
+    name: string;
+    createdTime: string;
+    modifiedTime: string;
+}
+
+export type TSpreadSheetColumn = {
+    id: string;
+    name: string;
+    createdTime: string;
+    modifiedTime: string;
+}

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

@@ -0,0 +1,17 @@
+export * from './waitlist';
+export * from './account';
+export * from './ai';
+export * from './agent';
+export * from './tenant';
+export * from './task';
+export * from './builder';
+export * from './scheduled-job';
+export * from './hooks';
+export * from './datasource';
+export * from './google';
+export * from './notion';
+export * from './emploid';
+export * from './bpm';
+export * from './mail';
+export * from './accounv1';
+export * from './organization';

package/src/modules/mail/action.ts

@@ -0,0 +1,22 @@
+'use server';
+
+import { z } from 'zod';
+import { AppcondaException } from '../../client';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { SendMailSchema } from './schema';
+
+export const SendMail = async (parsedInput: z.infer<typeof SendMailSchema>) => {
+    try {
+        const { mail } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await mail.SendMail(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+

package/src/modules/mail/index.ts

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

package/src/modules/mail/schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+
+
+export const SendMailSchema = z.object({
+    to: z.string(),
+    subject: z.string(),
+    body: z.string()
+});

package/src/modules/mail/service.ts

@@ -0,0 +1,15 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { TMailSendResult } from "./types";
+import { SendMailSchema } from "./schema";
+
+export class MailService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.mail';
+    }
+
+    public async SendMail(payload: z.infer<typeof SendMailSchema>): Promise<TMailSendResult[]> {
+        return await this.actionCall('SendMail', payload);
+    }
+}

package/src/modules/mail/types.ts

@@ -0,0 +1,11 @@
+
+
+
+
+
+export type TMailSendResult = {
+    id: string;
+    title: string;
+    createdTime: string;
+    lastEditedTime: string;
+}

package/src/modules/notion/action.ts

@@ -0,0 +1,53 @@
+'use server';
+
+import { z } from 'zod';
+import { AppcondaException } from '../../client';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { ListNotionDatabasesSchema, ListNotionColumnsSchema, CreateNotionRowSchema } from './schema';
+
+export const ListNotionDatabases = async (parsedInput: z.infer<typeof ListNotionDatabasesSchema>) => {
+    try {
+        const { notion } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await notion.ListDatabases(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const ListNotionColumns = async (parsedInput: z.infer<typeof ListNotionColumnsSchema>) => {
+    try {
+        const { notion } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await notion.ListColumns(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+export const CreateNotionRow = async (parsedInput: z.infer<typeof CreateNotionRowSchema>) => {
+    try {
+        const { notion } = await getSDKForCurrentUser();
+        //@ts-ignore
+        const app = await notion.CreateRow(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+    

package/src/modules/notion/index.ts

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

package/src/modules/notion/schema.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+
+
+export const ListNotionDatabasesSchema = z.object({
+   dataSourceId: z.string()
+});
+
+export const ListNotionColumnsSchema = z.object({
+   dataSourceId: z.string(),
+   databaseId: z.string()
+});
+
+
+
+
+export const CreateNotionRowSchema = z.object({
+   dataSourceId: z.string(),
+   databaseId: z.string(),
+   data: z.any()
+});

package/src/modules/notion/service.ts

@@ -0,0 +1,26 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { TNotionDatabase, TNotionDatabaseColumn } from "./types";
+import { ListNotionDatabasesSchema, ListNotionColumnsSchema, CreateNotionRowSchema } from "./schema";
+
+export class NotionService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.notion';
+    }
+
+    public async ListDatabases(payload: z.infer<typeof ListNotionDatabasesSchema>): Promise<TNotionDatabase[]> {
+        return await this.actionCall('database', 'ListDatabases', payload);
+    }
+
+    public async ListColumns(payload: z.infer<typeof ListNotionColumnsSchema>): Promise<TNotionDatabaseColumn[]> {
+        return await this.actionCall('database', 'ListColumns', payload);
+    }
+
+    public async CreateRow(payload: z.infer<typeof CreateNotionRowSchema>): Promise<any> {
+        if (typeof payload.data === 'object') {
+            payload.data = JSON.stringify(payload.data);
+        }
+        return await this.actionCall('database', 'CreateRow', payload);
+    }
+}

package/src/modules/notion/types.ts

@@ -0,0 +1,14 @@
+
+
+export type TNotionDatabase = {
+    id: string;
+    title: string;
+    createdTime: string;
+    lastEditedTime: string;
+}
+
+export type TNotionDatabaseColumn = {
+    id: string;
+    name: string;
+    type: string;
+}