@foxtware/mineral 0.1.7 → 0.1.9

package/api/supabase/supabase.utils.js

@@ -0,0 +1,52 @@
+const { createClient } = require('@supabase/supabase-js');
+const { HOSTED } = require('../constants');
+const { credsFromPayload } = require('../utils');
+
+const SUPABASE_INSTANCES = new Map();
+
+const getSupabaseCacheKey = (credsPayload) => JSON.stringify(credsPayload);
+
+const getSupabaseClient = async (credsPayload) => {
+  const key = getSupabaseCacheKey(credsPayload);
+
+  if (SUPABASE_INSTANCES.has(key)) {
+    return SUPABASE_INSTANCES.get(key);
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+  const {
+    BASE_URL,
+    API_KEY,
+  } = creds;
+
+  if (!BASE_URL || !API_KEY) {
+    throw new Error('Missing Supabase creds');
+  }
+
+  const client = createClient(BASE_URL, API_KEY);
+  SUPABASE_INSTANCES.set(key, client);
+  return client;
+};
+
+const supabaseInterpreter = (response) => {
+  const { data, error } = response;
+
+  if (error) {
+    return {
+      ok: false,
+      error: {
+        details: error,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    data,
+  };
+};
+
+module.exports = {
+  getSupabaseClient,
+  supabaseInterpreter,
+};

package/api/supabase/supabaseRowDelete.js

@@ -0,0 +1,95 @@
+const { HOSTED } = require('../constants');
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+  ['deleteConfig'],
+]);
+
+const supabaseRowDelete = async (
+  credsPayload,
+  tableName,
+  deleteConfig,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+    deleteConfig,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  if (!deleteConfig || typeof deleteConfig !== 'object') {
+    return {
+      ok: false,
+      error: {
+        message: 'deleteConfig must be an object with either { field, value } or { conditions }',
+      },
+    };
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  let queryResponse;
+
+  if (deleteConfig.conditions) {
+    if (typeof deleteConfig.conditions !== 'object') {
+      return {
+        ok: false,
+        error: {
+          message: 'conditions must be an object with field-value pairs',
+        },
+      };
+    }
+
+    !HOSTED && console.log('Deleting row with conditions:', deleteConfig.conditions);
+
+    let query = client.from(tableName).delete();
+
+    Object.entries(deleteConfig.conditions).forEach(([field, value]) => {
+      query = query.eq(field, value);
+    });
+
+    queryResponse = await query.select();
+  } else if (deleteConfig.field && deleteConfig.value !== undefined) {
+    !HOSTED && console.log(`Deleting row where ${ deleteConfig.field } = ${ deleteConfig.value }`);
+
+    queryResponse = await client
+      .from(tableName)
+      .delete()
+      .eq(deleteConfig.field, deleteConfig.value)
+      .select();
+  } else {
+    return {
+      ok: false,
+      error: {
+        message: 'deleteConfig must have either { field, value } or { conditions }',
+      },
+    };
+  }
+
+  return supabaseInterpreter(queryResponse);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseRowDelete,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseRowDelete" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups",
+    "deleteConfig": { "field": "name", "value": "fire_flower" }
+  }'
+*/

package/api/supabase/supabaseRowGet.js

@@ -0,0 +1,58 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+  ['rowField'],
+  ['rowValue'],
+]);
+
+const supabaseRowGet = async (
+  credsPayload,
+  tableName,
+  rowField,
+  rowValue,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+    rowField,
+    rowValue,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  const response = await client
+    .from(tableName)
+    .select('*')
+    .eq(rowField, rowValue)
+    .single()
+  ;
+
+  return supabaseInterpreter(response);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseRowGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseRowGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups",
+    "rowField": "name",
+    "rowValue": "star"
+  }'
+*/

package/api/supabase/supabaseRowInsert.js

@@ -0,0 +1,56 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+  ['rowObject'],
+]);
+
+const supabaseRowInsert = async (
+  credsPayload,
+  tableName,
+  rowObject,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+    rowObject,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  const response = await client
+    .from(tableName)
+    .insert(rowObject)
+    .select()
+  ;
+
+  return supabaseInterpreter(response);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseRowInsert,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseRowInsert" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups",
+    "rowObject": [
+      { "name": "mushroom", "effect": "grow", "duration_seconds": null },
+      { "name": "star", "effect": "invincible", "duration_seconds": 10 }
+    ]
+  }'
+*/

package/api/supabase/supabaseRowUpdate.js

@@ -0,0 +1,58 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+  ['match'],
+  ['updatePayload'],
+]);
+
+const supabaseRowUpdate = async (
+  credsPayload,
+  tableName,
+  match,
+  updatePayload,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+    match,
+    updatePayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  const response = await client
+    .from(tableName)
+    .update(updatePayload)
+    .match(match)
+    .select()
+  ;
+
+  return supabaseInterpreter(response);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseRowUpdate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseRowUpdate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups",
+    "match": { "name": "star" },
+    "updatePayload": { "duration_seconds": 12 }
+  }'
+*/

package/api/supabase/supabaseRpc.js

@@ -0,0 +1,61 @@
+// https://supabase.com/docs/reference/javascript/rpc
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['rpcName'],
+]);
+
+const supabaseRpc = async (
+  credsPayload,
+  rpcName,
+  {
+    rpcArgs,
+    rpcOptions,
+    useMaybeSingle = false,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    rpcName,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  let query = client.rpc(rpcName, rpcArgs, rpcOptions);
+
+  if (useMaybeSingle) {
+    query = query.maybeSingle();
+  }
+
+  const response = await query;
+  return supabaseInterpreter(response);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseRpc,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseRpc" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "rpcName": "grant_powerup",
+    "options": {
+      "rpcArgs": { "player": "mario", "powerup": "1up_mushroom" },
+      "useMaybeSingle": true
+    }
+  }'
+*/

package/api/supabase/supabaseTableGet.js

@@ -0,0 +1,44 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient, supabaseInterpreter } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+]);
+
+const supabaseTableGet = async (
+  credsPayload,
+  tableName,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+  const response = await client.from(tableName).select('*');
+  return supabaseInterpreter(response);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseTableGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseTableGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups"
+  }'
+*/

package/api/supabase/supabaseTableGetAll.js

@@ -0,0 +1,86 @@
+const { HOSTED } = require('../constants');
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getSupabaseClient } = require('../supabase/supabase.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['tableName'],
+]);
+
+const supabaseTableGetAll = async (
+  credsPayload,
+  tableName,
+  {
+    orderBy = 'id',
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    tableName,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const client = await getSupabaseClient(credsPayload);
+
+  const rowsCountResponse = await client.from(tableName).select('*', { count: 'exact', head: true });
+  const { count: rowsCount } = rowsCountResponse;
+
+  const PAGE_SIZE = 1000;
+  let rowsFetched = 0;
+  let rows = [];
+
+  while (rowsFetched < rowsCount) {
+    const pageRowsResponse = await client
+      .from(tableName)
+      .select('*')
+      .order(orderBy)
+      .range(rowsFetched, (rowsFetched + PAGE_SIZE) - 1)
+    ;
+    const { data, error } = pageRowsResponse;
+
+    if (error) {
+      return {
+        ok: false,
+        error: {
+          message: error.message,
+        },
+      };
+    }
+
+    if (!data) {
+      break;
+    }
+
+    rows.push(...data);
+    rowsFetched += PAGE_SIZE;
+    !HOSTED && console.log(`${ rows.length } / ${ rowsCount }`);
+  }
+
+  return {
+    ok: true,
+    data: rows,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  supabaseTableGetAll,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/supabaseTableGetAll" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "supabase.mushroom_kingdom" },
+    "tableName": "powerups",
+    "options": { "orderBy": "name" }
+  }'
+*/

package/api/upstash/upstash.utils.js

@@ -0,0 +1,36 @@
+const { Redis } = require('@upstash/redis');
+const { credsFromPayload } = require('../utils');
+
+const UPSTASH_INSTANCES = new Map();
+
+const getRedisCacheKey = (credsPayload) => JSON.stringify(credsPayload);
+
+const getRedisInstance = async (credsPayload) => {
+  const key = getRedisCacheKey(credsPayload);
+
+  if (UPSTASH_INSTANCES.has(key)) {
+    return UPSTASH_INSTANCES.get(key);
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+  const {
+    BASE_URL,
+    TOKEN,
+  } = creds;
+
+  if (!BASE_URL || !TOKEN) {
+    throw new Error('Missing Upstash creds');
+  }
+
+  const redis = new Redis({
+    url: BASE_URL,
+    token: TOKEN,
+  });
+
+  UPSTASH_INSTANCES.set(key, redis);
+  return redis;
+};
+
+module.exports = {
+  getRedisInstance,
+};

package/api/upstash/upstashDel.js

@@ -0,0 +1,46 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getRedisInstance } = require('../upstash/upstash.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['key'],
+]);
+
+const upstashDel = async (
+  credsPayload,
+  key,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, key });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const redis = await getRedisInstance(credsPayload);
+
+  try {
+    const result = await redis.del(key);
+    return {
+      ok: true,
+      data: result,
+    };
+  } catch (error) {
+    console.error('upstashDel error', error);
+    return {
+      ok: false,
+      error: {
+        message: error.message,
+      },
+    };
+  }
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  upstashDel,
+  funcApiConfig,
+};

package/api/upstash/upstashExists.js

@@ -0,0 +1,46 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getRedisInstance } = require('../upstash/upstash.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['key'],
+]);
+
+const upstashExists = async (
+  credsPayload,
+  key,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, key });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const redis = await getRedisInstance(credsPayload);
+
+  try {
+    const result = await redis.exists(key);
+    return {
+      ok: true,
+      data: result === 1,
+    };
+  } catch (error) {
+    console.error('upstashExists error', error);
+    return {
+      ok: false,
+      error: {
+        message: error.message,
+      },
+    };
+  }
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  upstashExists,
+  funcApiConfig,
+};

package/api/upstash/upstashGet.js

@@ -0,0 +1,46 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { getRedisInstance } = require('../upstash/upstash.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['key'],
+]);
+
+const upstashGet = async (
+  credsPayload,
+  key,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, key });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const redis = await getRedisInstance(credsPayload);
+
+  try {
+    const result = await redis.get(key);
+    return {
+      ok: true,
+      data: result,
+    };
+  } catch (error) {
+    console.error('upstashGet error', error);
+    return {
+      ok: false,
+      error: {
+        message: error.message,
+      },
+    };
+  }
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  upstashGet,
+  funcApiConfig,
+};