@saltcorn/data 0.6.2-beta.0 → 0.6.2-beta.4

package/models/role.js

@@ -1,94 +0,0 @@
-/**
- * Role Database Access Layer
- * @category saltcorn-data
- * @module models/role
- * @subcategory models
- */
-const db = require("../db");
-const { contract, is } = require("contractis");
-/**
- * Role class
- * @category saltcorn-data
- */
-class Role {
-  /**
-   * Role constructor
-   * @param {object} o 
-   */
-  constructor(o) {
-    this.id = o.id;
-    this.role = o.role;
-    contract.class(this);
-  }
-
-  /**
-   * @param {*} uo 
-   * @returns {Role}
-   */
-  static async create(uo) {
-    const u = new Role(uo);
-
-    const ex = await Role.findOne({ id: u.id });
-    if (ex) return { error: `Role with this id already exists` };
-    await db.insert("_sc_roles", {
-      id: u.id,
-      role: u.role,
-    });
-    return u;
-  }
-
-  /**
-   * @param {*} where 
-   * @param {*} selectopts 
-   * @returns {Promise<Role[]>}
-   */
-  static async find(where, selectopts) {
-    const us = await db.select("_sc_roles", where, selectopts);
-    return us.map((u) => new Role(u));
-  }
-
-  /**
-   * @param {*} where 
-   * @returns {Promise<Role>}
-   */
-  static async findOne(where) {
-    const u = await db.selectMaybeOne("_sc_roles", where);
-    return u ? new Role(u) : u;
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async delete() {
-    const schema = db.getTenantSchemaPrefix();
-    await db.query(`delete FROM ${schema}_sc_roles WHERE id = $1`, [this.id]);
-  }
-
-  /**
-   * @param {*} row 
-   * @returns {Promise<void>}
-   */
-  async update(row) {
-    await db.update("_sc_roles", row, this.id);
-  }
-}
-
-Role.contract = {
-  variables: {
-    id: is.posint,
-    role: is.str,
-  },
-  methods: {
-    delete: is.fun([], is.promise(is.undefined)),
-  },
-  static_methods: {
-    find: is.fun(is.maybe(is.obj()), is.promise(is.array(is.class("Role")))),
-    findOne: is.fun(is.obj(), is.promise(is.maybe(is.class("Role")))),
-    create: is.fun(
-      is.obj({ id: is.posint, role: is.str }),
-      is.promise(is.or(is.obj({ error: is.str }), is.class("Role")))
-    ),
-  },
-};
-
-module.exports = Role;

package/models/scheduler.js

@@ -1,163 +0,0 @@
-/**
- * @category saltcorn-data
- * @module models/scheduler
- * @subcategory models
- */
-const Crash = require("./crash");
-const { eachTenant } = require("./tenant");
-const Trigger = require("./trigger");
-const db = require("../db");
-const { getState } = require("../db/state");
-const fetch = require("node-fetch");
-const EventLog = require("./eventlog");
-
-/**
- * @param {Date} date 
- * @param {number} plusSeconds 
- * @returns {Promise<void>}
- */
-const sleepUntil = (date, plusSeconds) => {
-  const waitTill = new Date();
-  waitTill.setTime(date.getTime() + 1000 * plusSeconds);
-  const now = new Date();
-  const ms = waitTill.getTime() - now.getTime();
-  return new Promise((resolve) => setTimeout(resolve, ms));
-};
-
-/**
- * @param {string} name 
- * @param {number} hours 
- * @returns {Promise<Trigger[]>}
- */
-const getIntervalTriggersDueNow = async (name, hours) => {
-  const state = getState();
-  const cfgField = `next_${name.toLowerCase()}_event`;
-  const now = new Date();
-  let due = state.getConfigCopy(cfgField, false);
-  //console.log({due, name, now});
-  if (!due) {
-    //first run, set rnd due
-    const due_in_hrs = Math.random() * hours;
-    if (hours < 4) now.setMinutes(now.getMinutes() + due_in_hrs * 60);
-    else now.setHours(now.getHours() + due_in_hrs);
-    await state.setConfig(cfgField, now);
-    return [];
-  }
-  due = new Date(due);
-  if (due > now) return [];
-  //console.log("after check", {due, name, now});
-  const triggers = await Trigger.find({ when_trigger: name });
-  due.setHours(due.getHours() + hours);
-  if (now > due) {
-    // we must have skipped events, e.g. if not running continuously
-    due = now;
-    due.setHours(due.getHours() + hours);
-  }
-  await state.setConfig(cfgField, due);
-  EventLog.create({
-    event_type: name,
-    channel: null,
-    user_id: null,
-    payload:null,
-    occur_at: new Date(),
-  });
-  return triggers;
-};
-
-let availabilityPassed = false;
-
-/**
- * @param {string} port 
- * @returns {Promise<void>}
- */
-const checkAvailability = async (port) => {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/auth/login`);
-    const pass = response.status < 400;
-    if (pass) availabilityPassed = true;
-    else if (availabilityPassed) {
-      console.error("Availability check failed, restarting...");
-      try {
-        await Crash.create(new Error("Availability check failed"), {
-          url: "/",
-          headers: {},
-        });
-      } catch {}
-      process.exit(1);
-    }
-  } catch (e) {
-    console.error("Error in availability check", e);
-    if (availabilityPassed) process.exit(1);
-  }
-};
-
-/**
- * @param {object} opts
- * @param {function} [opts.stop_when]
- * @param {number} [opts.number]
- * @param {boolean} opts.watchReaper
- * @param {string} opts.port
- * @param {boolean} opts.disableScheduler
- * @returns {Promise<void>}
- */
-const runScheduler = async ({
-  stop_when = () => false,
-  tickSeconds = 60 * 5,
-  watchReaper,
-  port,
-  disableScheduler,
-} = {}) => {
-  let stopit;
-  const run = async () => {
-    if (watchReaper) await checkAvailability(port);
-    if (disableScheduler) return;
-
-    stopit = await stop_when();
-    if (stopit) return;
-    await eachTenant(async () => {
-      const isRoot = db.getTenantSchema() === db.connectObj.default_schema;
-
-      EventLog.create({
-        event_type: "Often",
-        channel: null,
-        user_id: null,
-        payload:null,
-        occur_at: new Date(),
-      });
-
-      const triggers = await Trigger.find({ when_trigger: "Often" });
-      const trsHourly = await getIntervalTriggersDueNow("Hourly", 1);
-      const trsDaily = await getIntervalTriggersDueNow("Daily", 24);
-      const trsWeekly = await getIntervalTriggersDueNow("Weekly", 24 * 7);
-      const allTriggers = [
-        ...triggers,
-        ...trsHourly,
-        ...trsDaily,
-        ...trsWeekly,
-      ];
-      for (const trigger of allTriggers) {
-        try {
-          await trigger.runWithoutRow();
-        } catch (e) {
-          if (isRoot)
-            await Crash.create(e, {
-              url: `trigger: action ${trigger.action} id ${trigger.id}`,
-              headers: {},
-            });
-        }
-      }
-    });
-  };
-
-  let i = 0;
-  const firstrun = new Date();
-  await run();
-
-  while (!stopit) {
-    i += 1;
-    await sleepUntil(firstrun, tickSeconds * i);
-    await run();
-  }
-};
-
-module.exports = runScheduler;