pangea-server 3.3.141 → 3.3.143

package/dist/helpers/gemini.helpers.d.ts

@@ -3,5 +3,8 @@ type File = {
     mimetype: string;
 };
 type Part = string | File;
-export declare function generateIaText(content: string | Part[]): Promise<string | undefined>;
+export declare abstract class Gemini {
+    static GenerateText(content: string | Part[]): Promise<string | undefined>;
+    private static __GetAi;
+}
 export {};

package/dist/helpers/gemini.helpers.js

@@ -1,20 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateIaText = generateIaText;
+exports.Gemini = void 0;
 // helpers
 const helpers_1 = require("../helpers");
-async function generateIaText(content) {
-    const { GoogleGenAI } = await import('@google/genai');
-    const ai = new GoogleGenAI({ apiKey: (0, helpers_1.getEnvStr)('GEMINI_API_KEY') });
-    const contents = typeof content === 'string'
-        ? content
-        : await Promise.all(content.map(async (part) => {
-            if (typeof part === 'string')
-                return { text: part };
-            const blob = new Blob([new Uint8Array(part.buffer)], { type: part.mimetype });
-            const uploadedFile = await ai.files.upload({ file: blob });
-            return { fileData: { fileUri: uploadedFile.uri, mimeType: part.mimetype } };
-        }));
-    const response = await ai.models.generateContent({ model: 'gemini-2.5-flash-lite', contents });
-    return response.text;
+const MODEL = 'gemini-2.5-flash-lite';
+class Gemini {
+    static async GenerateText(content) {
+        const ai = await this.__GetAi();
+        const contents = typeof content === 'string'
+            ? content
+            : await Promise.all(content.map(async (part) => {
+                if (typeof part === 'string')
+                    return { text: part };
+                const blob = new Blob([new Uint8Array(part.buffer)], { type: part.mimetype });
+                const uploadedFile = await ai.files.upload({ file: blob });
+                return { fileData: { fileUri: uploadedFile.uri, mimeType: part.mimetype } };
+            }));
+        const response = await ai.models.generateContent({ model: MODEL, contents });
+        return response.text;
+    }
+    static async __GetAi() {
+        const { GoogleGenAI } = await import('@google/genai');
+        return new GoogleGenAI({ apiKey: (0, helpers_1.getEnvStr)('GEMINI_API_KEY') });
+    }
 }
+exports.Gemini = Gemini;

package/dist/helpers/google-calendar.helpers.d.ts

@@ -0,0 +1,85 @@
+type GetEventsOptions = {
+    maxresults?: number;
+    timemin?: Date;
+    timemax?: Date;
+    query?: string;
+};
+type CreateEventOptions = {
+    title: string;
+    description?: string;
+    location?: string;
+    start: Date;
+    end: Date;
+    attendees?: string[];
+    meet?: boolean;
+};
+type UpdateEventOptions = {
+    title?: string;
+    description?: string;
+    location?: string;
+    start?: Date;
+    end?: Date;
+    attendees?: string[];
+};
+export declare class GoogleCalendar {
+    private __calendar;
+    constructor({ accesstoken, refreshtoken }: {
+        accesstoken: string;
+        refreshtoken: string;
+    });
+    static GetAuthUrl(redirectTo: string): Promise<string>;
+    static GetTokens(code: string, redirectTo: string): Promise<{
+        accesstoken: string;
+        refreshtoken: string;
+    }>;
+    getEvent(eventId: string): Promise<{
+        id: string;
+        summary: string | null | undefined;
+        description: string | null | undefined;
+        location: string | null | undefined;
+        start: Date | undefined;
+        end: Date | undefined;
+        attendees: string[];
+        hangoutLink: string | null | undefined;
+        htmlLink: string | null | undefined;
+        status: string | null | undefined;
+    }>;
+    getEvents(options?: GetEventsOptions): Promise<{
+        id: string;
+        summary: string | null | undefined;
+        description: string | null | undefined;
+        location: string | null | undefined;
+        start: Date | undefined;
+        end: Date | undefined;
+        attendees: string[];
+        hangoutLink: string | null | undefined;
+        htmlLink: string | null | undefined;
+        status: string | null | undefined;
+    }[]>;
+    createEvent(options: CreateEventOptions): Promise<{
+        id: string;
+        summary: string | null | undefined;
+        description: string | null | undefined;
+        location: string | null | undefined;
+        start: Date | undefined;
+        end: Date | undefined;
+        attendees: string[];
+        hangoutLink: string | null | undefined;
+        htmlLink: string | null | undefined;
+        status: string | null | undefined;
+    }>;
+    updateEvent(eventId: string, options: UpdateEventOptions): Promise<{
+        id: string;
+        summary: string | null | undefined;
+        description: string | null | undefined;
+        location: string | null | undefined;
+        start: Date | undefined;
+        end: Date | undefined;
+        attendees: string[];
+        hangoutLink: string | null | undefined;
+        htmlLink: string | null | undefined;
+        status: string | null | undefined;
+    }>;
+    deleteEvent(eventId: string): Promise<void>;
+}
+export {};

package/dist/helpers/google-calendar.helpers.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCalendar = void 0;
+const googleapis_1 = require("googleapis");
+// helpers
+const helpers_1 = require("../helpers");
+const scopes = ['https://www.googleapis.com/auth/calendar.events'];
+class GoogleCalendar {
+    constructor({ accesstoken, refreshtoken }) {
+        const auth = getOAuth2();
+        auth.setCredentials({ access_token: accesstoken, refresh_token: refreshtoken });
+        this.__calendar = googleapis_1.google.calendar({ version: 'v3', auth });
+    }
+    // class methods
+    static async GetAuthUrl(redirectTo) {
+        const auth = getOAuth2();
+        return auth.generateAuthUrl({ access_type: 'offline', prompt: 'consent', scope: scopes, redirect_uri: redirectTo });
+    }
+    static async GetTokens(code, redirectTo) {
+        const auth = getOAuth2();
+        const { tokens } = await auth.getToken({ code, redirect_uri: redirectTo });
+        return { accesstoken: tokens.access_token, refreshtoken: tokens.refresh_token };
+    }
+    // methods
+    async getEvent(eventId) {
+        const response = await this.__calendar.events.get({ calendarId: 'primary', eventId });
+        return convertEvent(response.data);
+    }
+    async getEvents(options = {}) {
+        const response = await this.__calendar.events.list({
+            calendarId: 'primary',
+            maxResults: options.maxresults || 10,
+            timeMin: options.timemin?.toISOString(),
+            timeMax: options.timemax?.toISOString(),
+            q: options.query,
+            singleEvents: true,
+            orderBy: 'startTime',
+        });
+        return (response.data.items || []).map(convertEvent);
+    }
+    async createEvent(options) {
+        const response = await this.__calendar.events.insert({
+            calendarId: 'primary',
+            requestBody: {
+                summary: options.title,
+                description: options.description,
+                location: options.location,
+                start: { dateTime: options.start.toISOString() },
+                end: { dateTime: options.end.toISOString() },
+                attendees: options.attendees?.map((email) => ({ email })),
+                conferenceData: options.meet
+                    ? {
+                        createRequest: {
+                            requestId: `meet-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+                            conferenceSolutionKey: { type: 'hangoutsMeet' },
+                        },
+                    }
+                    : undefined,
+            },
+            conferenceDataVersion: options.meet ? 1 : undefined,
+        });
+        return convertEvent(response.data);
+    }
+    async updateEvent(eventId, options) {
+        const { title, description, location, start, end, attendees } = options;
+        const requestBody = {};
+        if (title !== undefined)
+            requestBody.summary = title;
+        if (description !== undefined)
+            requestBody.description = description;
+        if (location !== undefined)
+            requestBody.location = location;
+        if (start !== undefined)
+            requestBody.start = { dateTime: start.toISOString() };
+        if (end !== undefined)
+            requestBody.end = { dateTime: end.toISOString() };
+        if (attendees !== undefined)
+            requestBody.attendees = attendees.map((email) => ({ email }));
+        const response = await this.__calendar.events.patch({ calendarId: 'primary', eventId, requestBody });
+        return convertEvent(response.data);
+    }
+    async deleteEvent(eventId) {
+        await this.__calendar.events.delete({ calendarId: 'primary', eventId });
+    }
+}
+exports.GoogleCalendar = GoogleCalendar;
+// internal functions
+function getOAuth2() {
+    return new googleapis_1.google.auth.OAuth2({
+        clientId: (0, helpers_1.getEnvStr)('GOOGLE_CLIENT_ID'),
+        clientSecret: (0, helpers_1.getEnvStr)('GOOGLE_CLIENT_SECRET'),
+    });
+}
+function convertEvent(event) {
+    return {
+        id: event.id,
+        summary: event.summary,
+        description: event.description,
+        location: event.location,
+        start: event.start ? new Date(event.start.dateTime || event.start.date || '') : undefined,
+        end: event.end ? new Date(event.end.dateTime || event.end.date || '') : undefined,
+        attendees: event.attendees?.map((attendee) => attendee.email).filter(Boolean) || [],
+        hangoutLink: event.hangoutLink || event.conferenceData?.entryPoints?.find((ep) => ep.entryPointType === 'video')?.uri,
+        htmlLink: event.htmlLink,
+        status: event.status,
+    };
+}

package/dist/helpers/index.d.ts

@@ -5,6 +5,7 @@ export * from './env.helpers';
 export * from './error.helpers';
 export * from './file-storage.helpers';
 export * from './gemini.helpers';
+export * from './google-calendar.helpers';
 export * from './html-sanitize.helpers';
 export * from './job.helpers';
 export * from './mailer.helpers';

package/dist/helpers/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./env.helpers"), exports);
 __exportStar(require("./error.helpers"), exports);
 __exportStar(require("./file-storage.helpers"), exports);
 __exportStar(require("./gemini.helpers"), exports);
+__exportStar(require("./google-calendar.helpers"), exports);
 __exportStar(require("./html-sanitize.helpers"), exports);
 __exportStar(require("./job.helpers"), exports);
 __exportStar(require("./mailer.helpers"), exports);

package/dist/helpers/pass.helpers.js

@@ -10,16 +10,16 @@ const env_helpers_1 = require("./env.helpers");
 const COST = 12;
 class Pass {
     static Hash(password) {
-        return bcrypt_1.default.hash(signPassword(password), COST);
+        return bcrypt_1.default.hash(sign(password), COST);
     }
     static async Compare(password, hash) {
-        if (await bcrypt_1.default.compare(signPassword(password), hash))
+        if (await bcrypt_1.default.compare(sign(password), hash))
             return true;
         return bcrypt_1.default.compare(password, hash);
     }
 }
 exports.Pass = Pass;
 // internal functions
-function signPassword(password) {
+function sign(password) {
     return crypto_1.default.createHmac('sha256', (0, env_helpers_1.getEnvStr)('PASSWORD_SECRET')).update(password).digest('hex');
 }

package/dist/validator/validators.helpers.d.ts

@@ -21,6 +21,7 @@ export declare namespace Val {
     type Id = Val.Int & Val.GreaterEqual<1>;
     type IdOptional = Val.Id | 0;
     type Ids = Val.Id[];
+    type MaxItems<T extends number> = tags.MaxItems<T>;
     interface IdParams {
         id: Val.Id;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pangea-server",
   "description": "",
-  "version": "3.3.141",
+  "version": "3.3.143",
   "files": [
     "dist"
   ],
@@ -45,6 +45,7 @@
     "express": "4.21.2",
     "express-async-errors": "3.1.1",
     "express-rate-limit": "^8.1.0",
+    "googleapis": "^172.0.0",
     "helmet": "8.1.0",
     "http-status-codes": "2.3.0",
     "jsdom": "26.0.0",