powr-sdk-api 4.16.0 → 4.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -22,7 +22,9 @@ const {
22
22
  initializeTools,
23
23
  executeTasks,
24
24
  executeTool,
25
- createTask
25
+ createTask,
26
+ emitActivity,
27
+ emitAudit
26
28
  } = require("./managers");
27
29
  const {
28
30
  verifyToken
@@ -48,5 +50,7 @@ module.exports = {
48
50
  executeTasks,
49
51
  executeTool,
50
52
  createTask,
53
+ emitActivity,
54
+ emitAudit,
51
55
  getPowrDb
52
56
  };
@@ -0,0 +1,154 @@
1
+ "use strict";
2
+
3
+ const {
4
+ parseEvent,
5
+ buildEventDoc,
6
+ buildListQuery,
7
+ defaultGetDb
8
+ } = require("../utils/eventLog");
9
+ const COLLECTION = "activities";
10
+ const NOTIFY_PATH = "/ops/notify";
11
+ const FORWARD_MS = 8000;
12
+
13
+ /**
14
+ * Frozen Pulse notify contract (Gate C codes against this).
15
+ * Activities only. Audit never calls this.
16
+ *
17
+ * POST {PULSE_API_URL}/ops/notify
18
+ * Header: X-Service-Key: {PULSE_SERVICE_KEY}
19
+ * Body: {
20
+ * activityId, projectId, action, userIds[],
21
+ * title, body, link, actorId, targetType, targetId
22
+ * }
23
+ *
24
+ * Host never sends FCM. Unset PULSE_API_URL → store the activity, skip notify.
25
+ */
26
+
27
+ function pulseNotifyUrl(env = process.env) {
28
+ const base = String(env && env.PULSE_API_URL || "").trim().replace(/\/$/, "");
29
+ if (!base) return null;
30
+ return `${base}${NOTIFY_PATH}`;
31
+ }
32
+ function buildPulseNotifyBody({
33
+ activityId,
34
+ parsed,
35
+ notify
36
+ }) {
37
+ return {
38
+ activityId: String(activityId),
39
+ projectId: notify.projectId || parsed.projectId,
40
+ action: parsed.action,
41
+ userIds: notify.userIds,
42
+ title: notify.title,
43
+ body: notify.body,
44
+ link: notify.link,
45
+ actorId: parsed.userId != null ? String(parsed.userId) : null,
46
+ targetType: parsed.targetType,
47
+ targetId: parsed.targetId != null ? String(parsed.targetId) : null
48
+ };
49
+ }
50
+ async function forwardPulseNotify({
51
+ activityId,
52
+ parsed,
53
+ notify,
54
+ fetchImpl,
55
+ env
56
+ }) {
57
+ const url = pulseNotifyUrl(env);
58
+ if (!url) {
59
+ return {
60
+ forwarded: false,
61
+ skipped: "PULSE_API_URL unset"
62
+ };
63
+ }
64
+ const key = String(env && env.PULSE_SERVICE_KEY || "").trim();
65
+ if (!key) {
66
+ return {
67
+ forwarded: false,
68
+ skipped: "PULSE_SERVICE_KEY unset"
69
+ };
70
+ }
71
+ const body = buildPulseNotifyBody({
72
+ activityId,
73
+ parsed,
74
+ notify
75
+ });
76
+ const impl = fetchImpl || global.fetch;
77
+ if (typeof impl !== "function") {
78
+ return {
79
+ forwarded: false,
80
+ skipped: "fetch unavailable"
81
+ };
82
+ }
83
+ const controller = new AbortController();
84
+ const timer = setTimeout(() => controller.abort(), FORWARD_MS);
85
+ try {
86
+ const response = await impl(url, {
87
+ method: "POST",
88
+ redirect: "manual",
89
+ cache: "no-store",
90
+ signal: controller.signal,
91
+ headers: {
92
+ "Content-Type": "application/json",
93
+ "X-Service-Key": key
94
+ },
95
+ body: JSON.stringify(body)
96
+ });
97
+ const status = Number(response && response.status);
98
+ const ok = status >= 200 && status < 300;
99
+ return {
100
+ forwarded: ok,
101
+ status: Number.isFinite(status) ? status : null,
102
+ error: ok ? null : `HTTP ${status}`
103
+ };
104
+ } catch (error) {
105
+ const timedOut = error && (error.name === "AbortError" || error.name === "TimeoutError");
106
+ return {
107
+ forwarded: false,
108
+ status: null,
109
+ error: timedOut ? "Timed out" : "Request failed"
110
+ };
111
+ } finally {
112
+ clearTimeout(timer);
113
+ }
114
+ }
115
+ async function emitActivity(options, deps = {}) {
116
+ const parsed = parseEvent(options, {
117
+ allowNotify: true
118
+ });
119
+ const getDbImpl = deps.getDb || defaultGetDb;
120
+ const db = await getDbImpl();
121
+ const doc = buildEventDoc(parsed, deps.now || new Date());
122
+ const result = await db.collection(COLLECTION).insertOne(doc);
123
+ const insertedId = result.insertedId;
124
+ let notify = null;
125
+ if (parsed.notify) {
126
+ notify = await forwardPulseNotify({
127
+ activityId: insertedId,
128
+ parsed,
129
+ notify: parsed.notify,
130
+ fetchImpl: deps.fetchImpl || global.fetch,
131
+ env: deps.env || process.env
132
+ });
133
+ console.log("pulse notify", {
134
+ activityId: String(insertedId),
135
+ forwarded: notify.forwarded === true,
136
+ status: notify.status == null ? null : notify.status,
137
+ skipped: notify.skipped || null,
138
+ error: notify.error || null
139
+ });
140
+ }
141
+ return {
142
+ insertedId,
143
+ notify
144
+ };
145
+ }
146
+ module.exports = {
147
+ COLLECTION,
148
+ NOTIFY_PATH,
149
+ emitActivity,
150
+ buildListQuery,
151
+ buildPulseNotifyBody,
152
+ forwardPulseNotify,
153
+ pulseNotifyUrl
154
+ };
@@ -0,0 +1,154 @@
1
+ "use strict";
2
+
3
+ const {
4
+ emitActivity,
5
+ buildPulseNotifyBody,
6
+ forwardPulseNotify,
7
+ pulseNotifyUrl,
8
+ NOTIFY_PATH
9
+ } = require("./activities");
10
+ const {
11
+ parseEvent
12
+ } = require("../utils/eventLog");
13
+ const projectId = "69ca11dbdbc0b193a48e6ccd";
14
+ const actor = "6893ec11c19c093a5bf21720";
15
+ const other = "aaaaaaaaaaaaaaaaaaaaaaaa";
16
+ function validEmit(extra) {
17
+ return {
18
+ projectId,
19
+ action: "task_assigned",
20
+ userId: actor,
21
+ targetType: "task",
22
+ targetId: other,
23
+ metadata: {
24
+ source: "spriny-api"
25
+ },
26
+ ...extra
27
+ };
28
+ }
29
+ describe("buildPulseNotifyBody", () => {
30
+ it("is the Gate C contract — activities only, no kind", () => {
31
+ const parsed = parseEvent(validEmit(), {
32
+ allowNotify: true
33
+ });
34
+ const body = buildPulseNotifyBody({
35
+ activityId: "abc",
36
+ parsed,
37
+ notify: {
38
+ userIds: [other],
39
+ title: "Assigned",
40
+ body: "A task is yours",
41
+ link: "/tasks/1"
42
+ }
43
+ });
44
+ expect(body).toEqual({
45
+ activityId: "abc",
46
+ projectId,
47
+ action: "task_assigned",
48
+ userIds: [other],
49
+ title: "Assigned",
50
+ body: "A task is yours",
51
+ link: "/tasks/1",
52
+ actorId: actor,
53
+ targetType: "task",
54
+ targetId: other
55
+ });
56
+ expect(body.kind).toBeUndefined();
57
+ });
58
+ });
59
+ describe("forwardPulseNotify", () => {
60
+ const parsed = parseEvent(validEmit({
61
+ notify: {
62
+ userIds: [other],
63
+ title: "Assigned",
64
+ body: "A task is yours",
65
+ link: "/tasks/1"
66
+ }
67
+ }), {
68
+ allowNotify: true
69
+ });
70
+ const notify = parsed.notify;
71
+ it("skips when PULSE_API_URL is unset", async () => {
72
+ const fetchImpl = jest.fn();
73
+ const result = await forwardPulseNotify({
74
+ activityId: "abc",
75
+ parsed,
76
+ notify,
77
+ fetchImpl,
78
+ env: {}
79
+ });
80
+ expect(result).toEqual({
81
+ forwarded: false,
82
+ skipped: "PULSE_API_URL unset"
83
+ });
84
+ expect(fetchImpl).not.toHaveBeenCalled();
85
+ expect(pulseNotifyUrl({})).toBeNull();
86
+ });
87
+ it("POSTs /ops/notify once with the service key", async () => {
88
+ const fetchImpl = jest.fn().mockResolvedValue({
89
+ status: 202
90
+ });
91
+ const result = await forwardPulseNotify({
92
+ activityId: "abc",
93
+ parsed,
94
+ notify,
95
+ fetchImpl,
96
+ env: {
97
+ PULSE_API_URL: "https://pulse.example.test/",
98
+ PULSE_SERVICE_KEY: "pulse-key"
99
+ }
100
+ });
101
+ expect(result).toEqual({
102
+ forwarded: true,
103
+ status: 202,
104
+ error: null
105
+ });
106
+ expect(fetchImpl).toHaveBeenCalledTimes(1);
107
+ const [url, init] = fetchImpl.mock.calls[0];
108
+ expect(url).toBe(`https://pulse.example.test${NOTIFY_PATH}`);
109
+ expect(init.method).toBe("POST");
110
+ expect(init.headers["X-Service-Key"]).toBe("pulse-key");
111
+ expect(JSON.parse(init.body).kind).toBeUndefined();
112
+ });
113
+ });
114
+ describe("emitActivity", () => {
115
+ function fakeDb(insertedId = "id1") {
116
+ const insertOne = jest.fn().mockResolvedValue({
117
+ insertedId
118
+ });
119
+ return {
120
+ insertOne,
121
+ getDb: async () => ({
122
+ collection(name) {
123
+ expect(name).toBe("activities");
124
+ return {
125
+ insertOne
126
+ };
127
+ }
128
+ })
129
+ };
130
+ }
131
+ it("writes the timeline row and skips notify when Pulse env is unset", async () => {
132
+ const {
133
+ getDb,
134
+ insertOne
135
+ } = fakeDb();
136
+ const result = await emitActivity(validEmit({
137
+ notify: {
138
+ userIds: [other],
139
+ title: "Assigned",
140
+ body: "A task is yours"
141
+ }
142
+ }), {
143
+ getDb,
144
+ env: {},
145
+ fetchImpl: jest.fn()
146
+ });
147
+ expect(result.insertedId).toBe("id1");
148
+ expect(result.notify).toEqual({
149
+ forwarded: false,
150
+ skipped: "PULSE_API_URL unset"
151
+ });
152
+ expect(insertOne.mock.calls[0][0].kind).toBeUndefined();
153
+ });
154
+ });
@@ -0,0 +1,26 @@
1
+ "use strict";
2
+
3
+ const {
4
+ parseEvent,
5
+ buildEventDoc,
6
+ buildListQuery,
7
+ defaultGetDb
8
+ } = require("../utils/eventLog");
9
+ const COLLECTION = "audit";
10
+ async function emitAudit(options, deps = {}) {
11
+ const parsed = parseEvent(options, {
12
+ allowNotify: false
13
+ });
14
+ const getDbImpl = deps.getDb || defaultGetDb;
15
+ const db = await getDbImpl();
16
+ const doc = buildEventDoc(parsed, deps.now || new Date());
17
+ const result = await db.collection(COLLECTION).insertOne(doc);
18
+ return {
19
+ insertedId: result.insertedId
20
+ };
21
+ }
22
+ module.exports = {
23
+ COLLECTION,
24
+ emitAudit,
25
+ buildListQuery
26
+ };
@@ -0,0 +1,64 @@
1
+ "use strict";
2
+
3
+ const {
4
+ emitAudit
5
+ } = require("./audit");
6
+ const projectId = "69ca11dbdbc0b193a48e6ccd";
7
+ const actor = "6893ec11c19c093a5bf21720";
8
+ const uuid = "9ad595de-babf-44c4-baec-cb7b82675e47";
9
+ describe("emitAudit", () => {
10
+ function fakeDb(insertedId = "aud1") {
11
+ const insertOne = jest.fn().mockResolvedValue({
12
+ insertedId
13
+ });
14
+ return {
15
+ insertOne,
16
+ getDb: async () => ({
17
+ collection(name) {
18
+ expect(name).toBe("audit");
19
+ return {
20
+ insertOne
21
+ };
22
+ }
23
+ })
24
+ };
25
+ }
26
+ it("writes the audit table and never forwards Pulse", async () => {
27
+ const fetchImpl = jest.fn();
28
+ const {
29
+ getDb,
30
+ insertOne
31
+ } = fakeDb();
32
+ const result = await emitAudit({
33
+ projectId,
34
+ action: "urbanstall_refund_payment",
35
+ userId: actor,
36
+ targetType: "orders",
37
+ targetId: uuid,
38
+ metadata: {
39
+ source: "urbanstall-api"
40
+ }
41
+ }, {
42
+ getDb,
43
+ fetchImpl
44
+ });
45
+ expect(result.insertedId).toBe("aud1");
46
+ expect(result.notify).toBeUndefined();
47
+ expect(fetchImpl).not.toHaveBeenCalled();
48
+ const doc = insertOne.mock.calls[0][0];
49
+ expect(doc.kind).toBeUndefined();
50
+ expect(doc.targetId).toBe(uuid);
51
+ expect(doc.action).toBe("urbanstall_refund_payment");
52
+ });
53
+ it("rejects a notify payload", async () => {
54
+ await expect(emitAudit({
55
+ projectId,
56
+ action: "urbanstall_order_cancelled",
57
+ notify: {
58
+ userIds: [actor],
59
+ title: "Cancelled",
60
+ body: "No"
61
+ }
62
+ })).rejects.toThrow("audit does not notify");
63
+ });
64
+ });
@@ -3,6 +3,12 @@
3
3
  const functionsManager = require('./functions');
4
4
  const toolsManager = require('./tools');
5
5
  const scheduledTasksManager = require('./tasks');
6
+ const {
7
+ emitActivity
8
+ } = require('./activities');
9
+ const {
10
+ emitAudit
11
+ } = require('./audit');
6
12
 
7
13
  // Async Functions initialization function
8
14
  const initializeFunctions = async (options = {}) => {
@@ -33,5 +39,7 @@ module.exports = {
33
39
  initializeTools,
34
40
  executeTasks,
35
41
  executeTool,
36
- createTask
42
+ createTask,
43
+ emitActivity,
44
+ emitAudit
37
45
  };
@@ -5,23 +5,35 @@ const router = express.Router();
5
5
  const {
6
6
  getDb
7
7
  } = require("../services/mongo");
8
-
9
- // Get all activities
8
+ const {
9
+ emitActivity,
10
+ buildListQuery
11
+ } = require("../managers/activities");
10
12
  router.get("/", async (req, res) => {
11
13
  try {
12
- const {
13
- contentId
14
- } = req.query;
15
- const projectId = req.projectId; // Use middleware-injected projectId
16
-
17
- const query = {
18
- projectId
19
- };
20
- if (contentId) {
21
- query.contentId = contentId;
14
+ let query;
15
+ let limit;
16
+ try {
17
+ ({
18
+ query,
19
+ limit
20
+ } = buildListQuery({
21
+ projectId: req.projectId,
22
+ contentId: req.query.contentId,
23
+ action: req.query.action,
24
+ source: req.query.source,
25
+ limit: req.query.limit
26
+ }));
27
+ } catch (error) {
28
+ return res.status(error.statusCode || 400).json({
29
+ success: false,
30
+ message: error.message
31
+ });
22
32
  }
23
33
  const db = await getDb();
24
- const activities = await db.collection("activities").find(query).toArray();
34
+ const activities = await db.collection("activities").find(query).sort({
35
+ createdAt: -1
36
+ }).limit(limit).toArray();
25
37
  return res.json({
26
38
  success: true,
27
39
  data: activities
@@ -34,16 +46,13 @@ router.get("/", async (req, res) => {
34
46
  });
35
47
  }
36
48
  });
37
-
38
- // Create new activity
39
49
  router.post("/", async (req, res) => {
40
50
  try {
41
51
  const {
42
52
  contentId,
43
53
  activity
44
54
  } = req.body;
45
- const projectId = req.projectId; // Use middleware-injected projectId
46
-
55
+ const projectId = req.projectId;
47
56
  if (!contentId || !activity) {
48
57
  return res.status(400).json({
49
58
  success: false,
@@ -71,4 +80,38 @@ router.post("/", async (req, res) => {
71
80
  });
72
81
  }
73
82
  });
83
+ router.post("/emit", async (req, res) => {
84
+ try {
85
+ const body = req.body || {};
86
+ const {
87
+ insertedId,
88
+ notify
89
+ } = await emitActivity({
90
+ projectId: req.projectId || body.projectId,
91
+ action: body.action,
92
+ userId: body.userId,
93
+ targetType: body.targetType,
94
+ targetId: body.targetId,
95
+ metadata: body.metadata,
96
+ notify: body.notify
97
+ });
98
+ return res.status(201).json({
99
+ success: true,
100
+ id: insertedId && insertedId.toString ? insertedId.toString() : String(insertedId),
101
+ notify
102
+ });
103
+ } catch (error) {
104
+ if (error.statusCode) {
105
+ return res.status(error.statusCode).json({
106
+ success: false,
107
+ message: error.message
108
+ });
109
+ }
110
+ console.error("activities emit:", error);
111
+ return res.status(500).json({
112
+ success: false,
113
+ message: error.message || "Failed to emit activity"
114
+ });
115
+ }
116
+ });
74
117
  module.exports = router;
@@ -0,0 +1,80 @@
1
+ "use strict";
2
+
3
+ const express = require("express");
4
+ const router = express.Router();
5
+ const {
6
+ getDb
7
+ } = require("../services/mongo");
8
+ const {
9
+ emitAudit,
10
+ buildListQuery
11
+ } = require("../managers/audit");
12
+ router.get("/", async (req, res) => {
13
+ try {
14
+ let query;
15
+ let limit;
16
+ try {
17
+ ({
18
+ query,
19
+ limit
20
+ } = buildListQuery({
21
+ projectId: req.projectId,
22
+ action: req.query.action,
23
+ source: req.query.source,
24
+ limit: req.query.limit
25
+ }));
26
+ } catch (error) {
27
+ return res.status(error.statusCode || 400).json({
28
+ success: false,
29
+ message: error.message
30
+ });
31
+ }
32
+ const db = await getDb();
33
+ const rows = await db.collection("audit").find(query).sort({
34
+ createdAt: -1
35
+ }).limit(limit).toArray();
36
+ return res.json({
37
+ success: true,
38
+ data: rows
39
+ });
40
+ } catch (error) {
41
+ console.error("Error retrieving audit:", error);
42
+ return res.status(500).json({
43
+ success: false,
44
+ message: "Failed to retrieve audit."
45
+ });
46
+ }
47
+ });
48
+ router.post("/emit", async (req, res) => {
49
+ try {
50
+ const body = req.body || {};
51
+ const {
52
+ insertedId
53
+ } = await emitAudit({
54
+ projectId: req.projectId || body.projectId,
55
+ action: body.action,
56
+ userId: body.userId,
57
+ targetType: body.targetType,
58
+ targetId: body.targetId,
59
+ metadata: body.metadata,
60
+ notify: body.notify
61
+ });
62
+ return res.status(201).json({
63
+ success: true,
64
+ id: insertedId && insertedId.toString ? insertedId.toString() : String(insertedId)
65
+ });
66
+ } catch (error) {
67
+ if (error.statusCode) {
68
+ return res.status(error.statusCode).json({
69
+ success: false,
70
+ message: error.message
71
+ });
72
+ }
73
+ console.error("audit emit:", error);
74
+ return res.status(500).json({
75
+ success: false,
76
+ message: error.message || "Failed to emit audit"
77
+ });
78
+ }
79
+ });
80
+ module.exports = router;
@@ -23,6 +23,7 @@ const ratingsRoutes = require('./ratings');
23
23
  const usersRoutes = require('./users');
24
24
  const waitlistsRoutes = require('./waitlists');
25
25
  const activitiesRoutes = require('./activities');
26
+ const auditRoutes = require('./audit');
26
27
  const trackRoutes = require('./track');
27
28
  const authRoutes = require('./auth');
28
29
  const loginCodeRoutes = require('./loginCode');
@@ -56,7 +57,8 @@ const createPowrRoutes = (options = {}) => {
56
57
  router.use('/users/me/preferences', verifyToken, preferencesRoutes);
57
58
  router.use('/users', verifyTokenOrServiceKey, usersRoutes);
58
59
  router.use('/waitlists', verifyToken, waitlistsRoutes);
59
- router.use('/activities', verifyToken, activitiesRoutes);
60
+ router.use('/activities', verifyTokenOrServiceKey, activitiesRoutes);
61
+ router.use('/audit', verifyTokenOrServiceKey, auditRoutes);
60
62
  router.use('/track', verifyToken, trackRoutes);
61
63
  router.use('/slides', verifyToken, slidesRoutes);
62
64
  router.use('/notifications', verifyToken, notificationsRoutes);
@@ -153,7 +153,7 @@ router.post("/", async (req, res) => {
153
153
  projectId: String(req.projectId),
154
154
  kind: "http",
155
155
  ...fields,
156
- nextRun: fields.enabled ? now : null,
156
+ nextRun: fields.enabled ? nextRunFromCron(fields.cron, now) : null,
157
157
  lastRunAt: null,
158
158
  lastOk: null,
159
159
  lastStatus: null,
@@ -196,12 +196,33 @@ router.patch("/:id", async (req, res) => {
196
196
  try {
197
197
  const db = await getDb();
198
198
  if (!(await requireActor(db, req, res))) return;
199
+ const existing = await db.collection(COLLECTION).findOne({
200
+ _id: oid,
201
+ projectId: String(req.projectId)
202
+ });
203
+ if (!existing) {
204
+ return res.status(404).json({
205
+ success: false,
206
+ message: "Schedule not found."
207
+ });
208
+ }
199
209
  const now = new Date();
200
210
  const update = {
201
211
  ...patch,
202
212
  updatedAt: now
203
213
  };
204
- if (patch.enabled === true) update.nextRun = now;
214
+ const turningOn = patch.enabled === true;
215
+ const cronChangedWhileOn = patch.cron && existing.enabled === true && patch.enabled !== false;
216
+ if (turningOn || cronChangedWhileOn) {
217
+ try {
218
+ update.nextRun = nextRunFromCron(patch.cron || existing.cron, now);
219
+ } catch (error) {
220
+ return res.status(error.statusCode || 400).json({
221
+ success: false,
222
+ message: error.message
223
+ });
224
+ }
225
+ }
205
226
  const result = await db.collection(COLLECTION).findOneAndUpdate({
206
227
  _id: oid,
207
228
  projectId: String(req.projectId)
@@ -0,0 +1,117 @@
1
+ "use strict";
2
+
3
+ const {
4
+ ObjectId
5
+ } = require("mongodb");
6
+ const MAX_USER_IDS = 100;
7
+ function reject(message, statusCode = 400) {
8
+ const error = new Error(message);
9
+ error.statusCode = statusCode;
10
+ throw error;
11
+ }
12
+ function isObjectIdString(id) {
13
+ return typeof id === "string" && id.length === 24 && ObjectId.isValid(id);
14
+ }
15
+ function normalizeId(id) {
16
+ if (id == null || id === "") return null;
17
+ if (typeof id === "string" && isObjectIdString(id)) return new ObjectId(id);
18
+ return id;
19
+ }
20
+ function parseNotify(notify) {
21
+ if (notify == null) return null;
22
+ if (typeof notify !== "object" || Array.isArray(notify)) {
23
+ reject("notify must be an object.");
24
+ }
25
+ if (!Array.isArray(notify.userIds)) {
26
+ reject("notify.userIds is required.");
27
+ }
28
+ const userIds = notify.userIds.map(id => String(id || "").trim()).filter(Boolean);
29
+ if (userIds.length === 0) reject("notify.userIds is required.");
30
+ if (userIds.length > MAX_USER_IDS) {
31
+ reject("notify.userIds must be 100 or fewer.");
32
+ }
33
+ const title = String(notify.title || "").trim();
34
+ if (!title) reject("notify.title is required.");
35
+ if (title.length > 140) reject("notify.title must be under 140 characters.");
36
+ const body = String(notify.body || "").trim();
37
+ if (!body) reject("notify.body is required.");
38
+ if (body.length > 2000) reject("notify.body must be under 2000 characters.");
39
+ const linkRaw = notify.link == null ? "" : String(notify.link).trim();
40
+ if (linkRaw.length > 500) reject("notify.link must be under 500 characters.");
41
+ const projectId = notify.projectId == null || notify.projectId === "" ? null : String(notify.projectId).trim();
42
+ return {
43
+ userIds,
44
+ title,
45
+ body,
46
+ link: linkRaw || null,
47
+ projectId
48
+ };
49
+ }
50
+ function parseEvent(options, {
51
+ allowNotify = false
52
+ } = {}) {
53
+ const source = options || {};
54
+ const projectId = String(source.projectId || "").trim();
55
+ const action = String(source.action || "").trim();
56
+ if (!projectId) reject("projectId is required.");
57
+ if (!action) reject("action is required.");
58
+ if (action.length > 80) reject("action must be under 80 characters.");
59
+ if (source.kind != null && source.kind !== "") {
60
+ reject("kind is not used. POST /activities/emit or POST /audit/emit.");
61
+ }
62
+ if (!allowNotify && source.notify != null) {
63
+ reject("audit does not notify.");
64
+ }
65
+ const metadata = source.metadata && typeof source.metadata === "object" && !Array.isArray(source.metadata) ? source.metadata : {};
66
+ return {
67
+ projectId,
68
+ action,
69
+ userId: normalizeId(source.userId),
70
+ targetType: source.targetType ? String(source.targetType).trim() : null,
71
+ targetId: normalizeId(source.targetId),
72
+ metadata,
73
+ notify: allowNotify ? parseNotify(source.notify) : null
74
+ };
75
+ }
76
+ function buildEventDoc(parsed, now = new Date()) {
77
+ return {
78
+ projectId: parsed.projectId,
79
+ action: parsed.action,
80
+ userId: parsed.userId,
81
+ targetType: parsed.targetType,
82
+ targetId: parsed.targetId,
83
+ metadata: parsed.metadata,
84
+ createdAt: now
85
+ };
86
+ }
87
+ function buildListQuery({
88
+ projectId,
89
+ contentId,
90
+ action,
91
+ source,
92
+ limit
93
+ } = {}) {
94
+ const query = {
95
+ projectId
96
+ };
97
+ if (contentId) query.contentId = contentId;
98
+ if (action) query.action = String(action);
99
+ if (source) query["metadata.source"] = String(source);
100
+ const lim = Math.min(Math.max(parseInt(limit, 10) || 100, 1), 500);
101
+ return {
102
+ query,
103
+ limit: lim
104
+ };
105
+ }
106
+ function defaultGetDb() {
107
+ return require("../services/mongo").getDb();
108
+ }
109
+ module.exports = {
110
+ reject,
111
+ normalizeId,
112
+ parseNotify,
113
+ parseEvent,
114
+ buildEventDoc,
115
+ buildListQuery,
116
+ defaultGetDb
117
+ };
@@ -0,0 +1,120 @@
1
+ "use strict";
2
+
3
+ const {
4
+ ObjectId
5
+ } = require("mongodb");
6
+ const {
7
+ parseEvent,
8
+ parseNotify,
9
+ buildEventDoc,
10
+ buildListQuery,
11
+ normalizeId
12
+ } = require("./eventLog");
13
+ const projectId = "69ca11dbdbc0b193a48e6ccd";
14
+ const actor = "6893ec11c19c093a5bf21720";
15
+ const other = "aaaaaaaaaaaaaaaaaaaaaaaa";
16
+ const uuid = "9ad595de-babf-44c4-baec-cb7b82675e47";
17
+ function validEvent(extra) {
18
+ return {
19
+ projectId,
20
+ action: "task_assigned",
21
+ userId: actor,
22
+ targetType: "task",
23
+ targetId: other,
24
+ metadata: {
25
+ source: "spriny-api"
26
+ },
27
+ ...extra
28
+ };
29
+ }
30
+ describe("parseEvent", () => {
31
+ it("requires projectId and action", () => {
32
+ expect(() => parseEvent({})).toThrow("projectId");
33
+ expect(() => parseEvent({
34
+ projectId
35
+ })).toThrow("action");
36
+ });
37
+ it("rejects kind — use the activity or audit door", () => {
38
+ expect(() => parseEvent(validEvent({
39
+ kind: "audit"
40
+ }))).toThrow("kind is not used");
41
+ });
42
+ it("keeps a UUID targetId as a string", () => {
43
+ const parsed = parseEvent(validEvent({
44
+ targetId: uuid
45
+ }));
46
+ expect(parsed.targetId).toBe(uuid);
47
+ expect(parsed.userId).toBeInstanceOf(ObjectId);
48
+ expect(String(parsed.userId)).toBe(actor);
49
+ });
50
+ it("rejects notify on audit", () => {
51
+ expect(() => parseEvent(validEvent({
52
+ notify: {
53
+ userIds: [other],
54
+ title: "Ping",
55
+ body: "Hi"
56
+ }
57
+ }), {
58
+ allowNotify: false
59
+ })).toThrow("audit does not notify");
60
+ });
61
+ });
62
+ describe("normalizeId", () => {
63
+ it("does not coerce a 12-character string", () => {
64
+ expect(normalizeId("hello-worlds")).toBe("hello-worlds");
65
+ });
66
+ });
67
+ describe("parseNotify", () => {
68
+ it("returns null when omitted", () => {
69
+ expect(parseNotify(undefined)).toBeNull();
70
+ });
71
+ it("requires userIds, title, and body", () => {
72
+ expect(() => parseNotify({})).toThrow("userIds");
73
+ expect(() => parseNotify({
74
+ userIds: [actor]
75
+ })).toThrow("title");
76
+ expect(() => parseNotify({
77
+ userIds: [actor],
78
+ title: "Ping"
79
+ })).toThrow("body");
80
+ });
81
+ });
82
+ describe("buildListQuery", () => {
83
+ it("filters action and source, and caps limit", () => {
84
+ const {
85
+ query,
86
+ limit
87
+ } = buildListQuery({
88
+ projectId,
89
+ action: "urbanstall_refund_payment",
90
+ source: "urbanstall-api",
91
+ limit: "999"
92
+ });
93
+ expect(query).toEqual({
94
+ projectId,
95
+ action: "urbanstall_refund_payment",
96
+ "metadata.source": "urbanstall-api"
97
+ });
98
+ expect(query.kind).toBeUndefined();
99
+ expect(limit).toBe(500);
100
+ });
101
+ });
102
+ describe("buildEventDoc", () => {
103
+ it("does not persist kind or notify on the row", () => {
104
+ const parsed = parseEvent(validEvent({
105
+ notify: {
106
+ userIds: [other],
107
+ title: "Assigned",
108
+ body: "A task is yours"
109
+ }
110
+ }), {
111
+ allowNotify: true
112
+ });
113
+ const now = new Date("2026-10-12T00:00:00.000Z");
114
+ const doc = buildEventDoc(parsed, now);
115
+ expect(doc.kind).toBeUndefined();
116
+ expect(doc.notify).toBeUndefined();
117
+ expect(doc.createdAt).toBe(now);
118
+ expect(doc.action).toBe("task_assigned");
119
+ });
120
+ });
@@ -106,18 +106,39 @@ function parseMethod(value) {
106
106
  if (method !== "GET" && method !== "POST") reject("Method must be GET or POST.");
107
107
  return method;
108
108
  }
109
+ function parseKeyEnv(value) {
110
+ if (value == null || value === "") return null;
111
+ const name = String(value).trim();
112
+ if (!/^[A-Z][A-Z0-9_]{0,63}$/.test(name)) {
113
+ reject("Service key env must be an uppercase env name.");
114
+ }
115
+ return name;
116
+ }
117
+ function configuredServiceKey(row, env) {
118
+ const name = row && row.keyEnv;
119
+ if (!name) return "";
120
+ if (!/^[A-Z][A-Z0-9_]{0,63}$/.test(String(name))) {
121
+ reject("Service key is not configured.");
122
+ }
123
+ const value = env && env[name];
124
+ if (!value) reject("Service key is not configured.");
125
+ return String(value);
126
+ }
109
127
  function parseScheduleCreate(body) {
110
128
  const source = body || {};
111
129
  const name = parseName(source.name);
112
130
  const cron = String(source.cron || "").trim();
113
131
  nextRunFromCron(cron, new Date());
114
- return {
132
+ const parsed = {
115
133
  name,
116
134
  cron,
117
135
  method: parseMethod(source.method),
118
136
  url: assertPublicHttpsUrl(source.url),
119
137
  enabled: source.enabled === true
120
138
  };
139
+ const keyEnv = parseKeyEnv(source.keyEnv);
140
+ if (keyEnv) parsed.keyEnv = keyEnv;
141
+ return parsed;
121
142
  }
122
143
  function parseSchedulePatch(body) {
123
144
  const source = body || {};
@@ -134,6 +155,11 @@ function parseSchedulePatch(body) {
134
155
  if (typeof source.enabled !== "boolean") reject("Enabled must be true or false.");
135
156
  patch.enabled = source.enabled;
136
157
  }
158
+ if (source.keyEnv !== undefined) {
159
+ const keyEnv = parseKeyEnv(source.keyEnv);
160
+ if (!keyEnv) reject("Service key env must be an uppercase env name.");
161
+ patch.keyEnv = keyEnv;
162
+ }
137
163
  if (!Object.keys(patch).length) reject("Nothing to update.");
138
164
  return patch;
139
165
  }
@@ -219,7 +245,7 @@ function updatedDoc(raw) {
219
245
  if (raw._id) return raw;
220
246
  return null;
221
247
  }
222
- async function fireTarget(row, fetchImpl = global.fetch) {
248
+ async function fireTarget(row, fetchImpl = global.fetch, env = process.env) {
223
249
  let url;
224
250
  try {
225
251
  url = assertPublicHttpsUrl(row && row.url);
@@ -240,6 +266,21 @@ async function fireTarget(row, fetchImpl = global.fetch) {
240
266
  error: error.message
241
267
  };
242
268
  }
269
+ let serviceKey = "";
270
+ if (row && row.keyEnv) {
271
+ try {
272
+ serviceKey = configuredServiceKey(row, env);
273
+ } catch (error) {
274
+ return {
275
+ ok: false,
276
+ status: null,
277
+ error: "Service key is not configured."
278
+ };
279
+ }
280
+ }
281
+ const headers = {};
282
+ if (method === "POST") headers["Content-Type"] = "application/json";
283
+ if (serviceKey) headers["X-Service-Key"] = serviceKey;
243
284
  const controller = new AbortController();
244
285
  const timer = setTimeout(() => controller.abort(), FIRE_MS);
245
286
  try {
@@ -248,9 +289,7 @@ async function fireTarget(row, fetchImpl = global.fetch) {
248
289
  redirect: "manual",
249
290
  cache: "no-store",
250
291
  signal: controller.signal,
251
- headers: method === "POST" ? {
252
- "Content-Type": "application/json"
253
- } : undefined,
292
+ headers: Object.keys(headers).length ? headers : undefined,
254
293
  body: method === "POST" ? "{}" : undefined
255
294
  });
256
295
  const status = Number(response && response.status);
@@ -24,6 +24,14 @@ describe("nextRunFromCron", () => {
24
24
  it("rejects a nickname", () => {
25
25
  expect(() => nextRunFromCron("@hourly")).toThrow("5-field cron");
26
26
  });
27
+ it("lands on 23:30 India time, not the next minute", () => {
28
+ const morning = new Date("2026-10-09T04:00:00.000Z");
29
+ const next = nextRunFromCron("30 23 * * *", morning);
30
+ expect(next.toISOString()).toBe("2026-10-09T18:00:00.000Z");
31
+ const afterClose = new Date("2026-10-09T18:00:01.000Z");
32
+ const tomorrow = nextRunFromCron("30 23 * * *", afterClose);
33
+ expect(tomorrow.toISOString()).toBe("2026-10-10T18:00:00.000Z");
34
+ });
27
35
  });
28
36
  describe("isDue", () => {
29
37
  const now = new Date("2026-10-09T10:01:00.000Z");
@@ -88,6 +96,24 @@ describe("parseScheduleCreate", () => {
88
96
  enabled: false
89
97
  });
90
98
  });
99
+ it("keeps an uppercase service-key env name", () => {
100
+ expect(parseScheduleCreate({
101
+ name: "Day close",
102
+ cron: "30 23 * * *",
103
+ method: "POST",
104
+ url: "https://example.com/ops/day-close",
105
+ keyEnv: "URBANSTALL_SERVICE_KEY"
106
+ }).keyEnv).toBe("URBANSTALL_SERVICE_KEY");
107
+ });
108
+ it("rejects a service-key value pasted as the env name", () => {
109
+ expect(() => parseScheduleCreate({
110
+ name: "Day close",
111
+ cron: "30 23 * * *",
112
+ method: "POST",
113
+ url: "https://example.com/ops/day-close",
114
+ keyEnv: "not-an-env-name"
115
+ })).toThrow("uppercase env name");
116
+ });
91
117
  });
92
118
  describe("parseSchedulePatch", () => {
93
119
  it("accepts on/off", () => {
@@ -202,6 +228,39 @@ describe("fireTarget", () => {
202
228
  expect(ok.ok).toBe(true);
203
229
  expect(ok.error).toBe(null);
204
230
  });
231
+ it("sends the product service key on POST and does not call when it is missing", async () => {
232
+ const fetchImpl = jest.fn(async () => ({
233
+ status: 200
234
+ }));
235
+ const ok = await fireTarget({
236
+ url: "https://example.com/ops/day-close",
237
+ method: "POST",
238
+ keyEnv: "URBANSTALL_SERVICE_KEY"
239
+ }, fetchImpl, {
240
+ URBANSTALL_SERVICE_KEY: "test-key"
241
+ });
242
+ expect(ok.ok).toBe(true);
243
+ expect(fetchImpl).toHaveBeenCalledWith("https://example.com/ops/day-close", expect.objectContaining({
244
+ method: "POST",
245
+ body: "{}",
246
+ headers: {
247
+ "Content-Type": "application/json",
248
+ "X-Service-Key": "test-key"
249
+ }
250
+ }));
251
+ const skipped = jest.fn();
252
+ const missing = await fireTarget({
253
+ url: "https://example.com/ops/day-close",
254
+ method: "POST",
255
+ keyEnv: "URBANSTALL_SERVICE_KEY"
256
+ }, skipped, {});
257
+ expect(missing).toEqual({
258
+ ok: false,
259
+ status: null,
260
+ error: "Service key is not configured."
261
+ });
262
+ expect(skipped).not.toHaveBeenCalled();
263
+ });
205
264
  });
206
265
  describe("runDue", () => {
207
266
  it("fires a due row once and stores the fail", async () => {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "powr-sdk-api",
3
- "version": "4.16.0",
3
+ "version": "4.17.0",
4
4
  "description": "Shared API core library for PowrStack projects. Zero dependencies - works with Express, Next.js API routes, and other frameworks. All features are optional and install only what you need.",
5
5
  "main": "dist/index.js",
6
6
  "types": "dist/index.d.ts",