@omega.js/backend 0.1.0

package/dist/manager/routes/admin/firestore/query/post.js

@@ -0,0 +1,128 @@
+const _ = require('lodash');
+const powertools = require('node-powertools');
+
+/**
+ * POST /admin/firestore/query - Query Firestore collections
+ * Admin-only endpoint to run complex queries
+ */
+module.exports = async ({ ctx, user, settings, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return ctx.respond('Authentication required', { code: 401 });
+  }
+
+  // Require admin
+  if (!user.roles.admin) {
+    return ctx.respond('Admin required.', { code: 403 });
+  }
+
+  const queries = powertools.arrayify(settings.queries);
+
+  ctx.log('main(): Queries', queries);
+
+  // Run all queries
+  const docs = [];
+
+  const runQuery = async (query) => {
+    query = query || {};
+    query.where = powertools.arrayify(query.where || []);
+    query.filter = powertools.arrayify(query.filter || []);
+    query.orderBy = powertools.arrayify(query.orderBy || []);
+
+    if (!query.collection) {
+      return [];
+    }
+
+    let collection = admin.firestore().collection(query.collection);
+
+    // Apply where clauses
+    for (const where of query.where) {
+      collection = collection.where(where.field, where.operator, where.value);
+    }
+
+    // Apply orderBy
+    for (const order of query.orderBy) {
+      collection = collection.orderBy(order.field, order.order);
+    }
+
+    // Apply pagination
+    if (query.limit) {
+      collection = collection.limit(query.limit);
+    }
+    if (query.startAt) {
+      collection = collection.startAt(query.startAt);
+    }
+    if (query.startAfter) {
+      collection = collection.startAfter(query.startAfter);
+    }
+    if (query.endAt) {
+      collection = collection.endAt(query.endAt);
+    }
+    if (query.endBefore) {
+      collection = collection.endBefore(query.endBefore);
+    }
+
+    const snapshot = await collection.get();
+
+    snapshot.forEach((doc) => {
+      const exists = docs.find((item) => item.path === doc.ref.path);
+
+      if (!exists && checkFilter(doc.data(), query.filter)) {
+        docs.push({
+          path: doc.ref.path,
+          data: doc.data(),
+        });
+      }
+    });
+
+    // Apply filter index if provided
+    if (query.filterIndex) {
+      const iS = query.filterIndex[0];
+      let iF = query.filterIndex[1];
+      iF = iF > docs.length ? docs.length - 1 : iF;
+      return docs.slice(iS, iF);
+    }
+
+    return docs;
+  };
+
+  // Run all queries in parallel
+  const ran = await Promise.all(queries.map(runQuery))
+    .catch((e) => e);
+
+  if (ran instanceof Error) {
+    return ctx.respond(ran.message, { code: 500 });
+  }
+
+  return ctx.respond(docs);
+};
+
+function checkFilter(data, filters) {
+  for (const filter of filters) {
+    const fields = powertools.arrayify(`${filter.field}`.split(' || '));
+    const matches = filter.matches || '';
+    const regex = powertools.regexify(matches);
+
+    let innerPassed = false;
+
+    for (const field of fields) {
+      const value = _.get(data, field, undefined);
+
+      if (typeof value === 'undefined') {
+        innerPassed = false;
+        continue;
+      } else if (typeof value === 'string' && value.match(regex)) {
+        innerPassed = true;
+        break;
+      }
+    }
+
+    if (!innerPassed) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/dist/manager/routes/admin/hook/post.js

@@ -0,0 +1,104 @@
+/**
+ * POST /admin/hook - Run a hook or cron job manually
+ *
+ * Resolves the hook from multiple locations:
+ *   1. @omega.js/backend internal crons (e.g. path="cron/daily/blog-auto-publisher")
+ *   2. @omega.js/backend internal functions/core hooks
+ *   3. Consumer project root
+ *   4. Consumer hooks/ directory
+ *
+ * Supports both calling conventions:
+ *   - Function export: module.exports = async ({ Manager, ctx, ... }) => {}
+ *   - Class export: module.exports = class { main(ctx) {} }
+ */
+module.exports = async ({ ctx, Manager, user, settings, analytics }) => {
+
+  if (!user.authenticated && ctx.isProduction()) {
+    return ctx.respond('Authentication required', { code: 401 });
+  }
+
+  if (!user.roles.admin && ctx.isProduction()) {
+    return ctx.respond('Admin required.', { code: 403 });
+  }
+
+  if (!settings.path) {
+    return ctx.respond('Missing required parameter: path', { code: 400 });
+  }
+
+  ctx.log('Running hook:', settings.path);
+
+  const loaded = loadHook(ctx, settings.path);
+
+  if (!loaded) {
+    return ctx.respond(`Hook not found: ${settings.path}`, { code: 404 });
+  }
+
+  const hookName = settings.path.split('/').pop();
+  ctx.setLogPrefix(`hook/${hookName}()`);
+
+  try {
+    let result;
+
+    if (loaded.type === 'function') {
+      result = await loaded.handler({
+        Manager,
+        ctx,
+        context: {},
+        libraries: Manager.libraries,
+      });
+    } else {
+      const instance = loaded.handler;
+      instance.Manager = Manager;
+      instance.ctx = ctx;
+      instance.context = null;
+      instance.libraries = Manager.libraries;
+      result = await instance.main(ctx);
+    }
+
+    analytics.event('admin/hook', { path: settings.path });
+
+    return ctx.respond(result || { success: true });
+  } catch (e) {
+    ctx.error(`Hook error: ${e.message}`, e);
+    return ctx.respond(e.message, { code: 500 });
+  }
+};
+
+function loadHook(ctx, hookPath) {
+  const Manager = ctx.Manager;
+  const path = require('path');
+
+  const searchPaths = [
+    // @omega.js/backend internal crons + events (e.g. "cron/daily/blog-auto-publisher")
+    path.join(Manager.rootDirectory, 'events', hookPath),
+    // @omega.js/backend internal functions/core
+    path.join(Manager.rootDirectory, '..', '..', 'functions', 'core', hookPath),
+    // Consumer project root
+    path.join(Manager.cwd, hookPath),
+    // Consumer hooks/ directory
+    path.join(Manager.cwd, 'hooks', hookPath),
+  ];
+
+  for (const searchPath of searchPaths) {
+    const resolved = pathify(searchPath);
+    ctx.log('Trying path:', resolved);
+
+    try {
+      const mod = require(resolved);
+
+      if (typeof mod === 'function' && !mod.prototype?.main) {
+        return { type: 'function', handler: mod };
+      }
+
+      return { type: 'class', handler: new mod() };
+    } catch (e) {
+      // Continue to next path
+    }
+  }
+
+  return null;
+}
+
+function pathify(p) {
+  return `${p.replace(/\.js$/, '')}.js`;
+}

package/dist/manager/routes/admin/infer-contact/post.js

@@ -0,0 +1,35 @@
+/**
+ * POST /admin/infer-contact - Infer contact info from email addresses
+ * Admin-only endpoint for testing/debugging the inferContact pipeline
+ */
+const { inferContact } = require('../../../libraries/infer-contact.js');
+
+module.exports = async ({ ctx, user, settings }) => {
+
+  // Require authentication
+  if (!user.authenticated) {
+    return ctx.respond('Authentication required', { code: 401 });
+  }
+
+  // Require admin
+  if (!user.roles.admin) {
+    return ctx.respond('Admin required.', { code: 403 });
+  }
+
+  // Accept single email or array of emails. Schema defaults `emails` to [], so check length:
+  // an empty default should NOT shadow a provided single `email`.
+  const emails = Array.isArray(settings.emails) && settings.emails.length > 0
+    ? settings.emails
+    : [settings.email];
+
+  const results = await Promise.all(
+    emails
+      .filter(Boolean)
+      .map(async (email) => {
+        const result = await inferContact(email, ctx);
+        return { email, ...result };
+      })
+  );
+
+  return ctx.respond({ results });
+};

package/dist/manager/routes/admin/notification/post.js

@@ -0,0 +1,37 @@
+/**
+ * POST /admin/notification - Send FCM push notification
+ * Admin-only endpoint to send push notifications.
+ * Uses shared notification library (also used by marketing-campaigns cron).
+ */
+const notification = require('../../../libraries/notification.js');
+
+module.exports = async ({ ctx, user, settings, analytics }) => {
+  if (!user.authenticated) {
+    return ctx.respond('Authentication required', { code: 401 });
+  }
+  if (!user.roles.admin) {
+    return ctx.respond('Admin required.', { code: 403 });
+  }
+
+  if (!settings.notification.title || !settings.notification.body) {
+    return ctx.respond('Parameters <title> and <body> required', { code: 400 });
+  }
+
+  const result = await notification.send(ctx, {
+    title: settings.notification.title,
+    body: settings.notification.body,
+    icon: settings.notification.icon,
+    clickAction: settings.notification.clickAction
+      || settings.notification.click_action,
+    filters: {
+      tags: settings.filters.tags || false,
+      owner: settings.filters.owner || null,
+      token: settings.filters.token || null,
+      limit: settings.filters.limit || null,
+    },
+  });
+
+  analytics.event('admin/notification', { sent: result.sent });
+
+  return ctx.respond(result);
+};

package/dist/manager/routes/admin/payment/post.js

@@ -0,0 +1,56 @@
+/**
+ * POST /admin/payment - Payment provider webhook
+ * Admin-only endpoint to process payment events
+ */
+const jetpack = require('fs-jetpack');
+
+module.exports = async ({ ctx, Manager, user, settings, analytics }) => {
+
+  // Require authentication
+  if (!user.authenticated) {
+    return ctx.respond('Authentication required', { code: 401 });
+  }
+
+  // Require admin
+  if (!user.roles.admin) {
+    return ctx.respond('Admin required.', { code: 403 });
+  }
+
+  // Check for productId in payload
+  const productId = settings?.payload?.details?.productIdGlobal;
+  if (!productId) {
+    return ctx.respond('No productId', { code: 400 });
+  }
+
+  const providerPath = `${Manager.cwd}/payment-providers/${productId}.js`;
+
+  ctx.log('Loading payment provider:', providerPath);
+
+  // Check if provider exists
+  if (!jetpack.exists(providerPath)) {
+    ctx.warn('Subprovider does not exist:', providerPath);
+    return ctx.respond({});
+  }
+
+  // Load provider
+  let provider;
+  try {
+    provider = new (require(providerPath));
+    provider.Manager = Manager;
+  } catch (e) {
+    ctx.error('Subprovider failed to load:', providerPath, e);
+    return ctx.respond({});
+  }
+
+  // Process payment
+  const result = await provider.process(settings).catch(e => e);
+
+  if (result instanceof Error) {
+    return ctx.respond(`Payment provider @ "${providerPath}" failed: ${result}`, { code: 500 });
+  }
+
+  // Track analytics
+  analytics.event('admin/payment', { productId: productId });
+
+  return ctx.respond(result);
+};

package/dist/manager/routes/admin/post/deduplicate-image-alts.js

@@ -0,0 +1,52 @@
+/**
+ * Deduplicate alt-text across DIFFERENT image URLs.
+ *
+ * Image filenames in the admin/post route are derived from the markdown image's
+ * alt-text. Two images sharing alt-text would otherwise produce the same filename
+ * and overwrite each other on upload, causing the second image to "disappear"
+ * (both `@post/` references in the body resolve to the same file).
+ *
+ * Strategy: when a non-header image's alt collides with an earlier image's alt
+ * AND its URL is different, suffix the alt with ` (N)` (where N is the
+ * occurrence count). Same URL keeps its original alt — repeated embeds of the
+ * exact same image are not a collision and should resolve to the same file.
+ *
+ * @param {Array<{src: string, alt: string, header?: boolean}>} images — image
+ *   entries extracted from the body (plus optional header). Mutated in place:
+ *   `image.alt` is rewritten when a collision is detected.
+ * @param {string} body — markdown body string. Returned with any
+ *   `![oldAlt](src)` rewritten to `![newAlt](src)` for collisions.
+ * @returns {{images: Array, body: string}} mutated images array and rewritten body.
+ */
+module.exports = function deduplicateImageAlts(images, body) {
+  const seenAltByUrl = new Map();
+  const altCountByAlt = new Map();
+  let rewrittenBody = body;
+
+  for (const image of images) {
+    if (image.header) {
+      continue;
+    }
+
+    const existingForUrl = seenAltByUrl.get(image.src);
+    if (existingForUrl) {
+      // Same URL appeared earlier — reuse its (possibly already-suffixed) alt.
+      // Repeated embeds of the same image should resolve to the same upload.
+      image.alt = existingForUrl;
+      continue;
+    }
+
+    const count = (altCountByAlt.get(image.alt) || 0) + 1;
+    altCountByAlt.set(image.alt, count);
+
+    if (count > 1) {
+      const newAlt = `${image.alt} (${count})`;
+      rewrittenBody = rewrittenBody.split(`![${image.alt}](${image.src})`).join(`![${newAlt}](${image.src})`);
+      image.alt = newAlt;
+    }
+
+    seenAltByUrl.set(image.src, image.alt);
+  }
+
+  return { images, body: rewrittenBody };
+};

package/dist/manager/routes/admin/post/dispatch-deploy.js

@@ -0,0 +1,36 @@
+/**
+ * D13: content-publish implies deploy. After a post commit lands on the
+ * website repo, dispatch its build workflow — `settings.deploy: false` opts
+ * out; plain code/config commits deploy nothing (scaffolded workflows carry
+ * no push triggers). Non-fatal: the post exists either way; the outcome
+ * surfaces in the response payload as `deployDispatched`.
+ */
+const { buildDispatch, dispatchWorkflow } = require('../../../../vendor/devkit/deploy.js');
+const env = require('../../../libraries/env.js');
+
+const WORKFLOW = 'build.yml';
+
+module.exports = async function dispatchDeploy(ctx, octokit, settings) {
+  settings.deploy = settings.deploy !== false;
+  if (!settings.deploy) {
+    return settings;
+  }
+
+  const owner = settings.githubUser;
+  const repo = settings.githubRepo;
+
+  try {
+    // workflow_dispatch needs a real ref — use the repo's default branch
+    const { data } = await octokit.rest.repos.get({ owner, repo });
+    const plan = buildDispatch({ owner, repo, workflow: WORKFLOW, ref: data.default_branch });
+
+    await dispatchWorkflow(plan, { token: env.get('GH_TOKEN') });
+    settings.deployDispatched = true;
+    ctx.log(`dispatchDeploy(): dispatched ${WORKFLOW} on ${owner}/${repo}@${data.default_branch}`);
+  } catch (e) {
+    settings.deployDispatched = false;
+    ctx.warn(`dispatchDeploy(): deploy dispatch failed (post still committed): ${e.message}`);
+  }
+
+  return settings;
+};