@shushed/helpers 0.0.84 → 0.0.85

package/dist/index.d.ts

@@ -7,7 +7,6 @@ import { Context } from 'co-body';
 import * as _google_cloud_scheduler_build_protos_protos from '@google-cloud/scheduler/build/protos/protos';
 import { CloudSchedulerClient } from '@google-cloud/scheduler';
 import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
-import { CloudTasksClient } from '@google-cloud/tasks';
 import { BigQuery } from '@google-cloud/bigquery';
 
 declare const schema$p: {
@@ -29733,6 +29732,7 @@ declare class Secrets extends Runtime {
 interface CloudTasksHelperOpts {
     projectId: string;
     serviceAccount: string;
+    accessToken: string;
     envName: string;
     workflowId: string;
     triggerId: string;
@@ -29760,16 +29760,22 @@ interface CreateTaskOpts {
     };
 }
 declare class CloudTasksHelper extends Runtime {
-    private client;
     private projectId;
     private serviceAccount;
+    private accessToken;
     envName: string;
     workflowId: string;
     triggerId: string;
     private location;
-    constructor(opts: CloudTasksHelperOpts, cloudTasksClient: CloudTasksClient);
+    constructor(opts: CloudTasksHelperOpts);
     private getQueueName;
     private getQueuePath;
+    private getQueueApiUrl;
+    private getLocationApiUrl;
+    private queueExists;
+    private createOrUpdateQueue;
+    private listTasks;
+    private deleteTask;
     create(opts: CreateTaskOpts): Promise<false | string[]>;
     delete(topicName: string): Promise<boolean>;
 }

package/dist/index.js

@@ -110504,19 +110504,44 @@ var secret_default = Secrets;
 
 // src-public/cloudtasks.ts
 var import_crypto2 = __toESM(require("crypto"));
+async function gcpFetch(url, accessToken, options = {}) {
+  let res;
+  try {
+    res = await fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers || {},
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      const err = new Error(`GCP API error: ${res.status} ${res.statusText}`);
+      const body = await res.json().catch(() => ({
+        code: res.status
+      }));
+      err.message = body.error?.message || err.message;
+      err.code = body.error?.code || res.status;
+      throw err;
+    }
+  } catch (err) {
+    throw new Error(`GCP API error: ${err.message}`);
+  }
+  return res.json();
+}
 var CloudTasksHelper = class extends Runtime {
-  client;
   projectId;
   serviceAccount;
+  accessToken;
   envName;
   workflowId;
   triggerId;
   location = "europe-west2";
-  constructor(opts, cloudTasksClient) {
+  constructor(opts) {
     super(opts);
-    this.client = cloudTasksClient;
     this.projectId = opts.projectId;
     this.serviceAccount = opts.serviceAccount;
+    this.accessToken = opts.accessToken;
     this.envName = opts.envName;
     this.workflowId = opts.workflowId;
     this.triggerId = opts.triggerId;
@@ -110526,36 +110551,60 @@ var CloudTasksHelper = class extends Runtime {
     return `${infraPrefix}-${shortHash(this.triggerId)}`;
   }
   getQueuePath(topicName) {
-    return this.client.queuePath(this.projectId, this.location, this.getQueueName(topicName));
+    return `projects/${this.projectId}/locations/${this.location}/queues/${this.getQueueName(topicName)}`;
   }
-  async create(opts) {
-    const queuePath = this.getQueuePath(opts.topicName);
-    let queueExists = false;
-    let queue = null;
+  getQueueApiUrl(topicName) {
+    return `https://cloudtasks.googleapis.com/v2/${this.getQueuePath(topicName)}`;
+  }
+  getLocationApiUrl() {
+    return `https://cloudtasks.googleapis.com/v2/projects/${this.projectId}/locations/${this.location}`;
+  }
+  async queueExists(topicName) {
     try {
-      [queue] = await this.client.getQueue({ name: queuePath });
-      queueExists = true;
+      await gcpFetch(this.getQueueApiUrl(topicName), this.accessToken, { method: "GET" });
+      return true;
     } catch (err) {
-      if (err.code !== 5) throw err;
+      if (err.code === 5 || err.message?.includes("notFound")) return false;
+      throw err;
     }
+  }
+  async createOrUpdateQueue(topicName, retryConfig) {
+    const queuePath = this.getQueuePath(topicName);
+    const queueApiUrl = this.getQueueApiUrl(topicName);
+    const locationApiUrl = this.getLocationApiUrl();
     const queueConfig = {
       name: queuePath,
-      retryConfig: opts.retryConfig || { maxAttempts: 1 },
-      appEngineRoutingOverride: void 0
+      retryConfig: retryConfig || { maxAttempts: 1 }
     };
-    if (!queueExists) {
-      await this.client.createQueue({
-        parent: this.client.locationPath(this.projectId, this.location),
-        queue: queueConfig
+    if (!await this.queueExists(topicName)) {
+      await gcpFetch(`${locationApiUrl}/queues`, this.accessToken, {
+        method: "POST",
+        body: JSON.stringify(queueConfig)
+      });
+    } else {
+      await gcpFetch(queueApiUrl, this.accessToken, {
+        method: "PATCH",
+        body: JSON.stringify(queueConfig)
       });
-    } else if (queue?.retryConfig?.maxAttempts !== opts.retryConfig?.maxAttempts) {
-      await this.client.updateQueue({ queue: queueConfig });
     }
+  }
+  async listTasks(topicName) {
+    const url = `${this.getQueueApiUrl(topicName)}/tasks`;
+    const res = await gcpFetch(url, this.accessToken, { method: "GET" });
+    return res.tasks || [];
+  }
+  async deleteTask(taskName) {
+    const url = `https://cloudtasks.googleapis.com/v2/${taskName}`;
+    await gcpFetch(url, this.accessToken, { method: "DELETE" });
+  }
+  async create(opts) {
+    const queuePath = this.getQueuePath(opts.topicName);
+    await this.createOrUpdateQueue(opts.topicName, opts.retryConfig);
     if (opts.deleteExistingTasks) {
-      const [tasks] = await this.client.listTasks({ parent: queuePath });
+      const tasks = await this.listTasks(opts.topicName);
       await Promise.allSettled(tasks.map(async (task) => {
         try {
-          await this.client.deleteTask({ name: task.name });
+          await this.deleteTask(task.name);
         } catch (err) {
           if (err.code !== 5) throw err;
         }
@@ -110566,32 +110615,34 @@ var CloudTasksHelper = class extends Runtime {
     const createdTaskNames = [];
     for (let i = 0; i < repeat; i++) {
       const taskId = opts.doNotCreateIfExists ? import_crypto2.default.createHash("sha256").update(Object.entries(opts.extraQuery || {}).sort().map((x) => x.join("=")).join("&")).digest("base64").slice(0, 16) : null;
-      const scheduleTime = {
-        seconds: Math.floor(Date.now() / 1e3) + scheduleSeconds * (i + 1)
-      };
+      const scheduleTime = new Date(Date.now() + 1e3 * scheduleSeconds * (i + 1)).toISOString();
       const httpRequest = {
         httpMethod: opts.httpTarget.httpMethod || "POST",
-        url: opts.httpTarget.uri || this.runtimeUrl + `/executeWorkflow/${this.workflowId}/${this.triggerId}?cloud_task=${opts.topicName}&schedule_time=${scheduleTime.seconds}&${new URLSearchParams(opts.extraQuery).toString()}`,
+        url: opts.httpTarget.uri || this.runtimeUrl + `/executeWorkflow/${this.workflowId}/${this.triggerId}?cloud_task=${opts.topicName}&schedule_time=${scheduleTime}&${new URLSearchParams(opts.extraQuery).toString()}`,
         headers: opts.httpTarget.headers || {
           "Content-Type": "application/json",
           "User-Agent": "CloudTasks-Google"
         },
-        body: opts.httpTarget.body ? Buffer.from(JSON.stringify(opts.httpTarget.body)) : void 0,
+        body: opts.httpTarget.body ? Buffer.from(JSON.stringify(opts.httpTarget.body)).toString("base64") : void 0,
         oidcToken: {
           serviceAccountEmail: this.serviceAccount
         }
       };
       try {
-        const [task] = await this.client.createTask({
-          parent: queuePath,
+        const url = `${this.getQueueApiUrl(opts.topicName)}/tasks`;
+        const body = {
           task: {
-            name: taskId ? `${queuePath}/tasks/${taskId}` : `${queuePath}/tasks/${scheduleTime}-${(0, import_crypto2.randomUUID)()}`,
+            name: `${queuePath}/tasks/${taskId}`,
             scheduleTime,
             httpRequest
           }
+        };
+        const res = await gcpFetch(url, this.accessToken, {
+          method: "POST",
+          body: JSON.stringify(body)
         });
-        if (task.name) {
-          createdTaskNames.push(task.name);
+        if (res.name) {
+          createdTaskNames.push(res.name);
         }
       } catch (err) {
         if (err.code === 5) return false;
@@ -110602,9 +110653,9 @@ var CloudTasksHelper = class extends Runtime {
     return createdTaskNames;
   }
   async delete(topicName) {
-    const queuePath = this.getQueuePath(topicName);
+    const queueApiUrl = this.getQueueApiUrl(topicName);
     try {
-      await this.client.deleteQueue({ name: queuePath });
+      await gcpFetch(queueApiUrl, this.accessToken, { method: "DELETE" });
       return true;
     } catch (err) {
       if (err.code === 5) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "author": "",
   "license": "UNLICENSED",
   "description": "",