@foxtware/mineral 0.1.7 → 0.1.9

package/api/upstash/upstashSet.js

@@ -0,0 +1,64 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getRedisInstance } = require('../upstash/upstash.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['key'],
+  ['value'],
+]);
+
+const upstashSet = async (
+  credsPayload,
+  key,
+  value,
+  {
+    ex,
+    nx,
+    xx,
+    ...upstashSetOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    key,
+    value,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const redis = await getRedisInstance(credsPayload);
+
+  try {
+    const result = await redis.set(key, value, {
+      ...(ex !== undefined && { ex }),
+      ...(nx !== undefined && { nx }),
+      ...(xx !== undefined && { xx }),
+      ...upstashSetOptions,
+    });
+
+    return {
+      ok: true,
+      data: result,
+    };
+  } catch (error) {
+    console.error('upstashSet error', error);
+    return {
+      ok: false,
+      error: {
+        message: error.message,
+      },
+    };
+  }
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  upstashSet,
+  funcApiConfig,
+};

package/api/utils.js

@@ -10,6 +10,10 @@ const { getWorkspace } = require('./workspace');
 const wait = (ms) => new Promise((resolve, reject) => setTimeout(resolve, ms));
 
 const objHasAny = (obj, keys) => {
+  if (obj == null || typeof obj !== 'object') {
+    return false;
+  }
+
   return keys.some((key) => obj[key] !== undefined);
 };
 
@@ -423,9 +427,10 @@ class FetchClient {
     this.context = context;
     this.requestPreparer = requestPreparer; // can be a Chain
     this.responseInterpreter = responseInterpreter; // can be a Chain  
+    this.layers = [];
   }
 
-  async fetch({
+  async #fetch({
     url,
 
     // customFetch payload
@@ -496,6 +501,47 @@ class FetchClient {
 
     return response;
   }
+
+  use(layer) {
+    this.layers.push(layer);
+  }
+
+  async fetch(fetchPayload) {
+    const coreFetch = (payload) => this.#fetch(payload);
+  
+    let layeredFetch = coreFetch;
+    for (const layer of [...this.layers].reverse()) {
+      const currentNext = layeredFetch; // capture this iteration's `next`
+      layeredFetch = (payload) => layer(payload, currentNext);
+    }
+  
+    return await layeredFetch(fetchPayload);
+  }
+
+  /* Example layer
+
+  const withDressColours = async (payload, next) => {
+
+    let response = await next({
+      ...payload,
+      headers: { ...payload.headers, dress: 'blue/white' },
+    });
+
+    if (!response.ok) {
+      console.warn('blue/white failed, retrying with black/gold');
+      response = await next({
+        ...payload,
+        headers: { ...payload.headers, dress: 'black/gold' },
+      });
+    }
+
+    return response;
+
+  };
+
+  client.use(withDressColours);
+
+  */
 }
 
 const fetchClientCommonSteps = {
@@ -1134,6 +1180,10 @@ class ArgsWarden {
   }
 }
 
+const gidToId = (gid) => {
+  return gid.split('/').pop();
+};
+
 module.exports = {
   wait,
   timeMs,
@@ -1162,4 +1212,5 @@ module.exports = {
   Getter,
   sentenceCaseString,
   ArgsWarden,
+  gidToId,
 };

package/api/workable/workable.constants.js

@@ -0,0 +1,3 @@
+module.exports = {
+  MAX_PER_PAGE: 100,
+};

package/api/workable/workable.utils.js

@@ -0,0 +1,46 @@
+const {
+  FetchClient,
+  Chain,
+  appendUrlToBase,
+  fetchClientCommonSteps,
+} = require('../utils');
+
+// TODO: Allow creds failure (e.g. missing BASE_URL / ACCESS_TOKEN → INVALID_CREDS before fetch)
+const addUrlAndAuthHeaders = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds } = context;
+  const {
+    BASE_URL,
+    ACCESS_TOKEN,
+  } = creds;
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(BASE_URL, requestPayload.url),
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        Authorization: `Bearer ${ ACCESS_TOKEN }`,
+        ...requestPayload.headers,
+      },
+    },
+  };
+};
+
+const workableClientRequestPreparer = new Chain([
+  addUrlAndAuthHeaders,
+]);
+
+const workableClientResponseInterpreter = new Chain([
+  fetchClientCommonSteps.exitEarlyOnNotOk,
+]);
+
+const workableClient = new FetchClient({
+  requestPreparer: workableClientRequestPreparer,
+  responseInterpreter: workableClientResponseInterpreter,
+});
+
+module.exports = {
+  workableClient,
+};

package/api/workable/workableGet.js

@@ -0,0 +1,146 @@
+// https://workable.readme.io/reference/jobs
+
+const { credsFromPayload, ArgsWarden, Getter } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+const { MAX_PER_PAGE } = require('../workable/workable.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['url'],
+]);
+
+const digResults = (data, resultsKey) => {
+  if (resultsKey) {
+    return data?.[resultsKey] ?? [];
+  }
+
+  const arrayEntry = Object.entries(data || {}).find(([, value]) => Array.isArray(value));
+  return arrayEntry ? arrayEntry[1] : [];
+};
+
+const workableGetPacket = async (
+  creds,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+  } = {},
+) => {
+  return workableClient.fetch({
+    url,
+    params: {
+      limit: Math.min(perPage, MAX_PER_PAGE),
+      ...params,
+    },
+    context: {
+      creds,
+    },
+  });
+};
+
+const workableGetPaginator = async (currentParams, response) => {
+  const { args, options } = currentParams;
+
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const nextUrl = response?.data?.paging?.next;
+  if (!nextUrl) {
+    return [true];
+  }
+
+  const nextParams = Object.fromEntries(new URL(nextUrl).searchParams.entries());
+
+  return [false, {
+    args,
+    options: {
+      ...options,
+      params: nextParams,
+    },
+  }];
+};
+
+const workableGet = async (
+  returnGetter,
+
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    resultsKey,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    url,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  const getter = new Getter(
+    {
+      args: [creds, url],
+      options: {
+        params,
+        perPage,
+      },
+    },
+    {
+      func: workableGetPacket,
+      digester: (response) => {
+        if (!response?.ok) {
+          return [];
+        }
+
+        return digResults(response.data, resultsKey);
+      },
+      paginator: workableGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  return getter.run({ returnAll: true });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableGet: (...args) => workableGet(false, ...args),
+  workableGetter: (...args) => workableGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "url": "/jobs"
+  }'
+
+curl -X POST "http://localhost:8000/workableGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "url": "/jobs",
+    "options": {
+      "params": { "state": "published" },
+      "resultsKey": "jobs",
+      "limit": 10
+    }
+  }'
+*/

package/api/workable/workableJobCandidateCreate.js

@@ -0,0 +1,87 @@
+// https://workable.readme.io/reference/job-candidates-create
+
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const candidateValidator = (candidate) => {
+  return Boolean(candidate) && typeof candidate === 'object';
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+  ['candidate', candidateValidator],
+]);
+
+const workableJobCandidateCreate = async (
+  credsPayload,
+  shortcode,
+  candidate,
+  {
+    stage,
+    sourced = true,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+    candidate,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  return workableClient.fetch({
+    url: `/jobs/${ shortcode }/candidates`,
+    method: 'post',
+    body: {
+      sourced,
+      ...stage !== undefined && { stage },
+      candidate,
+    },
+    context: {
+      creds,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobCandidateCreate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobCandidateCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001",
+    "candidate": {
+      "name": "Jessie",
+      "email": "jessie@teamrocket.org"
+    }
+  }'
+
+curl -X POST "http://localhost:8000/workableJobCandidateCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001",
+    "candidate": {
+      "name": "James",
+      "email": "james@teamrocket.org"
+    },
+    "options": {
+      "sourced": false,
+      "stage": "applied"
+    }
+  }'
+*/

package/api/workable/workableJobGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/jobsshortcode
+
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  return workableClient.fetch({
+    url: `/jobs/${ shortcode }`,
+    context: {
+      creds,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/

package/api/workable/workableJobMembersGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/job-members
+
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobMembersGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  return workableClient.fetch({
+    url: `/jobs/${ shortcode }/members`,
+    context: {
+      creds,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobMembersGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobMembersGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/

package/api/workable/workableJobStagesGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/job-stages
+
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobStagesGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  return workableClient.fetch({
+    url: `/jobs/${ shortcode }/stages`,
+    context: {
+      creds,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobStagesGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobStagesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/

package/api/workable/workableJobsGet.js

@@ -0,0 +1,78 @@
+// https://workable.readme.io/reference/jobs
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableGet } = require('../workable/workableGet');
+const { MAX_PER_PAGE } = require('../workable/workable.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const workableJobsGet = async (
+  credsPayload,
+  {
+    state,
+    sinceId,
+    maxId,
+    createdAfter,
+    updatedAfter,
+    includeFields,
+    perPage,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const normalisedIncludeFields = Array.isArray(includeFields)
+    ? includeFields.join(',')
+    : includeFields;
+
+  const params = {
+    ...state !== undefined && { state },
+    ...sinceId !== undefined && { since_id: sinceId },
+    ...maxId !== undefined && { max_id: maxId },
+    ...createdAfter !== undefined && { created_after: createdAfter },
+    ...updatedAfter !== undefined && { updated_after: updatedAfter },
+    ...normalisedIncludeFields !== undefined && { include_fields: normalisedIncludeFields },
+  };
+
+  return workableGet(credsPayload, '/jobs', {
+    params,
+    perPage: perPage ?? MAX_PER_PAGE,
+    resultsKey: 'jobs',
+    ...getterOptions,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" }
+  }'
+
+curl -X POST "http://localhost:8000/workableJobsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "options": {
+      "state": "published",
+      "perPage": 10,
+      "includeFields": ["description", "requirements"]
+    }
+  }'
+*/

package/bin/mineral.js

@@ -11,6 +11,12 @@ if (command === 'host') {
   return;
 }
 
+if (command === 'hosting_preview') {
+  const { startHostingPreview } = require('../hosting/hostingPreview');
+  startHostingPreview();
+  return;
+}
+
 const { startServer } = require('../server');
 
 startServer();

package/hosting/.hosting.yml.sample

@@ -5,19 +5,17 @@ google_cloud_info:
 # TODO: consider credsPayload in google_cloud_info instead of workspace .creds.yml
 
 functions:
-  exampleFunction:
-    max_instances: 1
-    timeout: 300s
-    before_wrappers:
-      - allowCrossOriginCallsAndHandleOptions
-      - requireHostedApiKey
-    # entry_point: otherHandlerName
-
   pokemonPokeballThrow:
+    entry_point: functionWithDifferentNameIfNeeded
     max_instances: 1
     before_wrappers:
-      - checkTrainer
+      - checkPokeballInventory
+    after_wrappers:
+      - rethrowIfNotCaught
+    include_creds_paths:
+      - nintendo.pokemon
+      - platform
 
 groups:
-  example_group:
-    - exampleFunction
+  pokemon:
+    - pokemonPokeballThrow