@suss/packs 0.35.1 → 0.37.0

package/dist/bullmq.js

@@ -0,0 +1,138 @@
+// ../framework/bullmq/dist/index.js
+import { constructedFrom, messageSends, pack } from "@suss/recognize";
+var BULLMQ = "bullmq";
+var QUEUE = constructedFrom({ from: [BULLMQ], named: ["Queue"] });
+var FLOW_PRODUCER = constructedFrom({
+  from: [BULLMQ],
+  named: ["FlowProducer"]
+});
+var QUEUE_BUILT_WITH = [
+  { argument: { of: [{ to: "receiver" }], at: 0 } }
+];
+var QUEUE_NAMED_IN_THE_FLOW = [
+  { property: ["queueName"] }
+];
+function sendDeclarations() {
+  return [
+    messageSends({
+      wire: "bullmq",
+      client: QUEUE,
+      messages: { each: "theInput" },
+      channel: QUEUE_BUILT_WITH,
+      body: { whole: "message" },
+      routingKey: { at: 0 },
+      unsettledName: "nothing"
+    }).methods({ add: { input: { at: 1 } } }).example('queue.add("welcome", { userId })'),
+    messageSends({
+      wire: "bullmq",
+      client: QUEUE,
+      messages: { each: "inTheInput" },
+      channel: QUEUE_BUILT_WITH,
+      body: "data",
+      routingKey: "name",
+      unsettledName: "nothing"
+    }).methods({ addBulk: { input: { at: 0 } } }).example('queue.addBulk([{ name: "welcome", data: { userId } }])'),
+    // A job scheduler adds a job on every tick, from the template it is
+    // given here.
+    messageSends({
+      wire: "bullmq",
+      client: QUEUE,
+      messages: { each: "theInput" },
+      channel: QUEUE_BUILT_WITH,
+      body: "data",
+      routingKey: "name",
+      unsettledName: "nothing"
+    }).methods({ upsertJobScheduler: { input: { at: 2 } } }).example(
+      'queue.upsertJobScheduler("nightly", { pattern: "0 0 * * *" }, { name: "digest", data: {} })'
+    ),
+    messageSends({
+      wire: "bullmq",
+      client: FLOW_PRODUCER,
+      messages: { each: "theInput" },
+      channel: QUEUE_NAMED_IN_THE_FLOW,
+      body: "data",
+      routingKey: "name",
+      unsettledName: "nothing"
+    }).methods({ add: { input: { at: 0 } } }).example(
+      'flow.add({ name: "render", queueName: "renders", data: { id } })'
+    ),
+    messageSends({
+      wire: "bullmq",
+      client: FLOW_PRODUCER,
+      messages: { each: "inTheInput" },
+      channel: QUEUE_NAMED_IN_THE_FLOW,
+      body: "data",
+      routingKey: "name",
+      unsettledName: "nothing"
+    }).methods({ addBulk: { input: { at: 0 } } }).example(
+      'flow.addBulk([{ name: "render", queueName: "renders", data: { id } }])'
+    )
+  ];
+}
+function bullmqFramework() {
+  const sends = pack("bullmq", sendDeclarations(), {
+    languages: ["typescript", "javascript"],
+    recognizedAs: "@suss/framework-bullmq"
+  });
+  return {
+    ...sends,
+    discovery: [
+      {
+        kind: "consumer",
+        match: {
+          type: "callbackArgument",
+          importModule: BULLMQ,
+          importName: "Worker",
+          callbackPosition: 1
+        },
+        binding: {
+          semantics: "message-bus",
+          messageBus: "bullmq",
+          channel: { from: "callArgument", position: 0 }
+        },
+        requiresImport: [BULLMQ]
+      }
+    ],
+    terminals: [
+      // A processor's return value is the job's result, which BullMQ
+      // stores and nothing here pairs yet.
+      {
+        kind: "return",
+        match: { type: "returnStatement", excludeCallReturns: false },
+        extraction: {}
+      },
+      {
+        kind: "throw",
+        match: { type: "throwExpression" },
+        extraction: {}
+      },
+      // Most processors return nothing, and a job completes when its
+      // processor runs off the end.
+      {
+        kind: "return",
+        match: { type: "functionFallthrough" },
+        extraction: {}
+      }
+    ],
+    // The job is not the message: what the add sent is `job.data`, so
+    // the job keeps a role of its own rather than the one a message has.
+    inputMapping: {
+      type: "positionalParams",
+      params: [
+        { position: 0, role: "job" },
+        { position: 1, role: "token" }
+      ]
+    }
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-bullmq",
+  dependencies: [{ ecosystem: "npm", name: "bullmq" }],
+  reads: "BullMQ workers and queues: each worker's processor is a consumer on its queue, and each add to a queue is a message send on it."
+};
+var index_default = bullmqFramework;
+export {
+  declares,
+  index_default as default
+};

package/dist/celery.d.ts

@@ -0,0 +1 @@
+export { declares, default } from '@suss/framework-celery';

package/dist/celery.js

@@ -0,0 +1,53 @@
+// ../framework/celery/dist/index.js
+function celeryJobQueue() {
+  return {
+    messageBus: "celery",
+    module: "celery",
+    taskDecorators: ["task", "shared_task"],
+    nameKeyword: "name",
+    queueKeyword: "queue",
+    defaultName: "modulePath",
+    enqueueMethods: [
+      { method: "delay", arguments: { type: "spread" } },
+      {
+        method: "apply_async",
+        arguments: {
+          type: "packed",
+          args: { argument: 0, keyword: "args" },
+          kwargs: { argument: 1, keyword: "kwargs" }
+        }
+      }
+    ],
+    sendByName: [
+      {
+        method: "send_task",
+        name: { argument: 0, keyword: "name" },
+        arguments: {
+          type: "packed",
+          args: { argument: 1, keyword: "args" },
+          kwargs: { argument: 2, keyword: "kwargs" }
+        }
+      }
+    ],
+    apps: ["Celery", "current_app"]
+  };
+}
+function celeryFramework() {
+  return {
+    name: "celery",
+    protocol: "celery",
+    discovery: [],
+    jobQueues: [celeryJobQueue()]
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-celery",
+  dependencies: [{ ecosystem: "pypi", name: "celery" }],
+  reads: "Celery tasks (Python). A function under `@app.task` or `@shared_task` is the consumer of its task, and `.delay`, `.apply_async` and `send_task` are sends to it, so a route that enqueues a task reaches what the task does."
+};
+var index_default = celeryFramework;
+export {
+  declares,
+  index_default as default
+};