@saltcorn/db-common 0.6.2-beta.0 → 0.6.2-beta.4

package/internal.test.js

@@ -1,198 +0,0 @@
-const { sqlsanitize, mkWhere, sqlsanitizeAllowDots } = require("./internal");
-
-describe("sqlsanitize", () => {
-  it("should not alter valid name", () => {
-    expect(sqlsanitize("ffoo_oo")).toBe("ffoo_oo");
-  });
-  it("should not alter valid symbol", () => {
-    expect(sqlsanitize(Symbol("ffoo_oo"))).toBe("ffoo_oo");
-  });
-  it("should remove spaces", () => {
-    expect(sqlsanitize(" ")).toBe("");
-  });
-  it("should remove chars from invalid name", () => {
-    expect(sqlsanitize("ffoo--oo--uu")).toBe("ffoooouu");
-  });
-  it("should remove chars from invalid symbol", () => {
-    expect(sqlsanitize(Symbol("ffoo--oo--uu"))).toBe("ffoooouu");
-  });
-  it("should not allow dots", () => {
-    expect(sqlsanitize("ffoo.oo")).toBe("ffoooo");
-  });
-  it("should allow dots when specified", () => {
-    expect(sqlsanitizeAllowDots("ffoo.oo")).toBe("ffoo.oo");
-  });
-  it("should allow quotes when dots specified", () => {
-    expect(sqlsanitizeAllowDots('ffoo."oo"')).toBe('ffoo."oo"');
-  });
-  it("should allow numbers", () => {
-    expect(sqlsanitize("ff1oo_oo")).toBe("ff1oo_oo");
-  });
-  it("should not allow numbers in initial position", () => {
-    expect(sqlsanitize("1ffoo_o1o")).toBe("_1ffoo_o1o");
-  });
-});
-
-describe("mkWhere", () => {
-  it("should empty on no arg", () => {
-    expect(mkWhere()).toStrictEqual({ values: [], where: "" });
-  });
-  it("should empty on null obj arg", () => {
-    expect(mkWhere({})).toStrictEqual({ values: [], where: "" });
-  });
-  it("should query json", () => {
-    expect(mkWhere({ foo: { json: ["bar", 5] } })).toStrictEqual({
-      values: [5],
-      where: `where "foo"->>'bar'=$1`,
-    });
-  });
-
-  it("should set id", () => {
-    expect(mkWhere({ id: 5 })).toStrictEqual({
-      values: [5],
-      where: 'where "id"=$1',
-    });
-    expect(mkWhere({ id: 5, hello: "world" })).toStrictEqual({
-      values: [5, "world"],
-      where: 'where "id"=$1 and "hello"=$2',
-    });
-  });
-  it("should read eq", () => {
-    expect(mkWhere({ eq: [Symbol("id"), 5] })).toStrictEqual({
-      values: [5],
-      where: 'where "id"=$1',
-    });
-    expect(mkWhere({ eq: [Symbol("id"), null] })).toStrictEqual({
-      values: [],
-      where: 'where "id" is null',
-    });
-    expect(mkWhere({ eq: ["id", null] })).toStrictEqual({
-      values: ["id"],
-      where: "where $1::text is null",
-    });
-    expect(mkWhere({ eq: [4, 5] })).toStrictEqual({
-      values: [4, 5],
-      where: "where $1=$2",
-    });
-    expect(mkWhere({ eq: [null, 5] })).toStrictEqual({
-      values: [5],
-      where: "where $1 is null",
-    });
-    expect(mkWhere({ not: { eq: [Symbol("id"), 5] } })).toStrictEqual({
-      values: [5],
-      where: 'where not ("id"=$1)',
-    });
-  });
-  it("should query null", () => {
-    expect(mkWhere({ id: null })).toStrictEqual({
-      values: [],
-      where: 'where "id" is null',
-    });
-    expect(mkWhere({ id: null, foo: 1 })).toStrictEqual({
-      values: [1],
-      where: 'where "id" is null and "foo"=$1',
-    });
-    expect(mkWhere({ foo: 1, id: null })).toStrictEqual({
-      values: [1],
-      where: 'where "foo"=$1 and "id" is null',
-    });
-  });
-  it("should query lt/gt", () => {
-    expect(mkWhere({ id: { lt: 5 } })).toStrictEqual({
-      values: [5],
-      where: 'where "id"<$1',
-    });
-    expect(mkWhere({ id: { gt: 8 } })).toStrictEqual({
-      values: [8],
-      where: 'where "id">$1',
-    });
-    expect(mkWhere({ id: { lt: 5, equal: true } })).toStrictEqual({
-      values: [5],
-      where: 'where "id"<=$1',
-    });
-    expect(mkWhere({ id: { gt: 8, equal: true } })).toStrictEqual({
-      values: [8],
-      where: 'where "id">=$1',
-    });
-    expect(mkWhere({ id: [{ gt: 0 }, { lt: 10 }] })).toStrictEqual({
-      values: [0, 10],
-      where: 'where "id">$1 and "id"<$2',
-    });
-    expect(mkWhere({ id: { or: [{ gt: 10 }, { lt: 5 }] } })).toStrictEqual({
-      values: [10, 5],
-      where: 'where ("id">$1 or "id"<$2)',
-    });
-  });
-  it("should query subselect", () => {
-    expect(
-      mkWhere({
-        id: [{ inSelect: { table: "foo", field: "bar", where: { baz: 7 } } }],
-      })
-    ).toStrictEqual({
-      values: [7],
-      where: 'where "id" in (select bar from foo where "baz"=$1)',
-    });
-    expect(
-      mkWhere({
-        age: 45,
-        id: [{ inSelect: { table: "foo", field: "bar", where: { baz: 7 } } }],
-        name: "Alice",
-      })
-    ).toStrictEqual({
-      values: [45, 7, "Alice"],
-      where: `where "age"=$1 and "id" in (select bar from foo where "baz"=$2) and "name"=$3`,
-    });
-  });
-  it("should query or", () => {
-    expect(mkWhere({ or: [{ id: 5 }, { x: 7 }] })).toStrictEqual({
-      values: [5, 7],
-      where: 'where ("id"=$1 or "x"=$2)',
-    });
-    expect(mkWhere({ or: [{ id: 5 }, { x: { gt: 7 } }] })).toStrictEqual({
-      values: [5, 7],
-      where: 'where ("id"=$1 or "x">$2)',
-    });
-    expect(mkWhere({ or: [{ id: 5 }, { x: 7, y: 8 }] })).toStrictEqual({
-      values: [5, 7, 8],
-      where: 'where ("id"=$1 or "x"=$2 and "y"=$3)',
-    });
-    expect(mkWhere({ not: { id: 5 } })).toStrictEqual({
-      values: [5],
-      where: 'where not ("id"=$1)',
-    });
-    expect(mkWhere({ not: { id: 5, y: 1 } })).toStrictEqual({
-      values: [5, 1],
-      where: 'where not ("id"=$1 and "y"=$2)',
-    });
-    expect(mkWhere({ not: { y: { in: [1, 2, 3] } } })).toStrictEqual({
-      values: [[1, 2, 3]],
-      where: 'where not ("y" = ANY ($1))',
-    });
-    expect(mkWhere({ y: { in: [1, 2, 3] } })).toStrictEqual({
-      values: [[1, 2, 3]],
-      where: 'where "y" = ANY ($1)',
-    });
-    expect(
-      mkWhere({
-        or: [
-          { not: { eq: ["1", null] } },
-          { not: { eq: [null, null] }, married_to: null },
-        ],
-      })
-    ).toStrictEqual({
-      values: ["1"],
-      where:
-        'where (not ($1::text is null) or not (null is null) and "married_to" is null)',
-    });
-    /*
-
-    expect(mkWhere([{ id: 5 }, { x: 7 }])).toStrictEqual({
-      values: [5, 7],
-      where: 'where "id"=$1 and "x"=$2',
-    });
-    expect(mkWhere([{ or: [{ id: 5 }, { x: 7 }] }, { z: 9 }])).toStrictEqual({
-      values: [5, 7, 9],
-      where: 'where ("id"=$1 or "x"=$2) and "z"=$3',
-    });*/
-  });
-});

package/multi-tenant.js

@@ -1,48 +0,0 @@
-/**
- * @category db-common
- * @module multi-tenant
- */
-const { AsyncLocalStorage } = require("async_hooks");
-const { sqlsanitize } = require("./internal");
-
-var is_multi_tenant = true;
-
-/**
- * @returns {boolean}
- */
-const is_it_multi_tenant = () => is_multi_tenant;
-
-const tenantNamespace = new AsyncLocalStorage();
-
-/**  
- * @returns {object}
-*/
-const enable_multi_tenant = () => {};
-
-/**
- * @param {object} tenant 
- * @param {function} f 
- * @returns {object}
- */
-const runWithTenant = (tenant, f) => {
-  if (!is_multi_tenant) return f();
-  else return tenantNamespace.run(sqlsanitize(tenant).toLowerCase(), f);
-};
-
-module.exports = /**
- * @function
- * @name "module.exports function"
- * @returns {exports}
- */
-(connObj) => ({
-  /**
-   * @returns {object}
-   */
-  getTenantSchema() {
-    const storeVal = tenantNamespace.getStore();
-    return storeVal || connObj.default_schema;
-  },
-  enable_multi_tenant,
-  runWithTenant,
-  is_it_multi_tenant,
-});

package/single-tenant.js

@@ -1,30 +0,0 @@
-/**
- * @category db-common
- * @module single-tenant
- */
-
-module.exports = /**
- * @function
- * @name "module.exports function"
- * @returns {exports}
- */
-(connObj) => ({
-  /**
-   * @returns {string}
-   */
-  getTenantSchema: () => connObj.default_schema,
-  /** 
-   * @returns {false}
-   */
-  is_it_multi_tenant: () => false,
-  enable_multi_tenant() {},
-  /**
-   * @param {*} t 
-   * @param {function} f 
-   * @returns {*}
-   */
-  runWithTenant(t, f) {
-    return f();
-  },
-});
-

package/tenants.js

@@ -1,21 +0,0 @@
-/**
- * @category db-common
- * @module tenants
- */
-
-let tenantExport = null;
-
-
-module.exports = /**
- * @function
- * @name "module.exports function"
- * @returns {multi-tenant|single-tenant}
- */
-(connObj) => {
-  if(!tenantExport) {
-    tenantExport = connObj.multi_tenant ? 
-        require("./multi-tenant")(connObj)
-      : require("./single-tenant")(connObj);
-  }
-  return tenantExport;
-}