jinaga-server 2.6.1 → 3.0.0

package/test/postgres/postgresSpec.ts

@@ -1,391 +0,0 @@
-import "source-map-support/register";
-
-import {
-  dehydrateReference,
-  Direction,
-  ExistentialCondition,
-  fromDescriptiveString,
-  Join,
-  PropertyCondition,
-  Step,
-} from "jinaga";
-
-import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, ensureGetFactTypeId, getFactTypeId, getRoleId } from "../../src/postgres/maps";
-import { sqlFromSteps } from "../../src/postgres/sql";
-import { distinct } from "../../src/util/fn";
-
-describe('Postgres', () => {
-
-  const start = dehydrateReference({ type: 'Root' });
-  const startHash = 'fSS1hK7OGAeSX4ocN3acuFF87jvzCdPN3vLFUtcej0lOAsVV859UIYZLRcHUoMbyd/J31TdVn5QuE7094oqUPg==';
-
-  function sqlFor(descriptiveString: string) {
-    const query = fromDescriptiveString(descriptiveString);
-    const factTypes = allFactTypes(query.steps).filter(t => t !== 'Unknown').reduce(
-      (f, factType, i) => addFactType(f, factType, i + 1),
-      emptyFactTypeMap());
-    let roleMap = allRoles(query.steps, 'Root').filter(r => r.type !== 'Unknown' && r.role !== 'unknown').reduce(
-      (r, role, i) => addRole(r, ensureGetFactTypeId(factTypes, role.type), role.role, i + 1),
-      emptyRoleMap());
-    const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap, "public");
-    return sqlQuery ? { sql: sqlQuery.sql, parameters: sqlQuery.parameters, pathLength: sqlQuery.pathLength, empty: sqlQuery.empty, factTypes, roleMap } : null;
-  }
-
-  it('should parse empty query', () => {
-    expect(sqlFor('')).toEqual(null);
-  });
-
-  it('should error on successor query', () => {
-    const parse = () => sqlFor('S.predecessor');
-    expect(parse).toThrow('Missing type for role predecessor');
-  });
-
-  it('should error on predecessor query', () => {
-    const parse = () => sqlFor('P.parent');
-    expect(parse).toThrow(/Missing type of "Root.parent"/);
-  });
-
-  it('should error on double predecessor query', () => {
-    const parse = () => sqlFor('P.parent P.grandparent');
-    expect(parse).toThrow(/Missing type of "Root.parent"/);
-  });
-
-  it('should parse successor query with type', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.predecessor F.type="IntegrationTest.Successor"')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2'
-    );
-    expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-    expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
-    expect(pathLength).toEqual(1);
-  });
-
-  it('should parse predecessor query with type', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('P.parent F.type="Parent"')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.successor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.predecessor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2'
-    );
-    expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-    expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Root'), 'parent'));
-    expect(pathLength).toEqual(1);
-  });
-
-  it('should parse successor query with existential', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.predecessor F.type="IntegrationTest.Successor" E(S.successor F.type="IntegrationTest.Grandchild")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.predecessor_fact_id = e1.successor_fact_id AND e2.role_id = $4)'
-    );
-      expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-      expect(parameters[1]).toEqual(startHash);
-      expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
-      expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
-      expect(pathLength).toEqual(1);
-  });
-
-  it('should parse successor query with negative existential', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.predecessor F.type="IntegrationTest.Successor" N(S.successor F.type="IntegrationTest.Grandchild")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.predecessor_fact_id = e1.successor_fact_id AND e2.role_id = $4)'
-    );
-    expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-    expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
-    expect(pathLength).toEqual(1);
-  });
-
-  it('should parse successor query with existential predecessor', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.parent F.type="Child" E(P.uncle F.type="Uncle")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.successor_fact_id = e1.successor_fact_id AND e2.role_id = $4)'
-    );
-    expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-    expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'uncle'));
-    expect(pathLength).toEqual(1);
-  });
-
-  it('should parse successor query with negative existential predecessor', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.parent F.type="Child" N(P.uncle F.type="Uncle")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.successor_fact_id = e1.successor_fact_id AND e2.role_id = $4)'
-    );
-    expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
-    expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'uncle'));
-    expect(pathLength).toEqual(1);
-  });
-
-  it('should parse consecutive existential queries', () => {
-    const { sql, parameters, factTypes, roleMap } = sqlFor('S.parent F.type="Child" N(S.condition F.type="Condition") N(S.other F.type="Other")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.predecessor_fact_id = e1.successor_fact_id AND e2.role_id = $4) ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e3 ' +
-      'WHERE e3.predecessor_fact_id = e1.successor_fact_id AND e3.role_id = $5)'
-    );
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Condition'), 'condition'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Other'), 'other')
-    ]);
-  });
-
-  it('should parse existential query form predecessor', () => {
-    const { sql, parameters, factTypes, roleMap } = sqlFor('S.root F.type="Identifier" N(S.prior F.type="Identifier") P.identified F.type="Identified" N(S.identified F.type="Delete")')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2, f3.hash as hash3 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'JOIN public.edge e3 ON e3.successor_fact_id = e1.successor_fact_id AND e3.role_id = $5 ' +
-      'JOIN public.fact f3 ON f3.fact_id = e3.predecessor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e2 ' +
-      'WHERE e2.predecessor_fact_id = e1.successor_fact_id AND e2.role_id = $4) ' +
-      'AND NOT EXISTS (SELECT 1 ' +
-      'FROM public.edge e4 ' +
-      'WHERE e4.predecessor_fact_id = e3.predecessor_fact_id AND e4.role_id = $6)'
-    );
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'root'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'prior'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'identified'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Delete'), 'identified')
-    ]);
-  });
-
-  it('should error on existential query on predecessor with no type', () => {
-    const parse = () => sqlFor('S.root F.type="Identifier" N(S.prior F.type="Identifier") P.identified N(S.identified F.type="Delete")');
-    expect(parse).toThrow(/Missing type of "Identifier.identified"/);
-  });
-
-  it('should parse zig-zag pipeline', () => {
-    const { sql, parameters, pathLength, factTypes, roleMap } = sqlFor('S.user F.type="Assignment" P.project F.type="Project" S.project F.type="Task" S.task F.type="Task.Title"')!;
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2, f3.hash as hash3, f4.hash as hash4, f5.hash as hash5 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'JOIN public.edge e2 ON e2.successor_fact_id = e1.successor_fact_id AND e2.role_id = $4 ' +
-      'JOIN public.fact f3 ON f3.fact_id = e2.predecessor_fact_id ' +
-      'JOIN public.edge e3 ON e3.predecessor_fact_id = e2.predecessor_fact_id AND e3.role_id = $5 ' +
-      'JOIN public.fact f4 ON f4.fact_id = e3.successor_fact_id ' +
-      'JOIN public.edge e4 ON e4.predecessor_fact_id = e3.successor_fact_id AND e4.role_id = $6 ' +
-      'JOIN public.fact f5 ON f5.fact_id = e4.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2'
-    );
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'user'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'project'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Task'), 'project'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Task.Title'), 'task')
-    ]);
-    expect(pathLength).toEqual(4);
-  });
-
-  it('should parse query with unknown successor type', () => {
-    const { empty } = sqlFor('S.root F.type="Unknown"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse query with unknown predecessor type', () => {
-    const { empty } = sqlFor('S.root F.type="Assignment" P.pred F.type="Unknown" P.user F.type="Jinaga.User"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse query with some unknown types', () => {
-    const { empty } = sqlFor('S.root F.type="Unknown" P.user F.type="Jinaga.User"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse query with unknown successor role', () => {
-    const { empty } = sqlFor('S.unknown F.type="Successor"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse query with unknown predecessor role', () => {
-    const { empty } = sqlFor('S.root F.type="Assignment" P.unknown F.type="Jinaga.User"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse query with some unknown predecessor roles', () => {
-    const { empty } = sqlFor('S.root F.type="Assignment" P.predecessor F.type="Predecessor" P.unknown F.type="Jinaga.User"')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should ignore negative existential with unknown type', () => {
-    const { empty, sql, parameters, factTypes, roleMap } = sqlFor('S.root F.type="Assignment" N(S.assignment F.type="Unknown")')!;
-    expect(empty).toBeFalsy();
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2'
-    );
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'root')
-    ]);
-  });
-
-  it('should ignore negative existential with unknown role', () => {
-    const { empty, sql, parameters, factTypes, roleMap } = sqlFor('S.root F.type="Assignment" N(S.unknown F.type="Assignment.Delete")')!;
-    expect(empty).toBeFalsy();
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2'
-    );
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'root')
-    ]);
-  });
-
-  it('should elevate positive existential with unknown type', () => {
-    const { empty } = sqlFor('S.root F.type="Assignment" E(S.assignment F.type="Unknown")')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should elevate positive existential with unknown role', () => {
-    const { empty } = sqlFor('S.root F.type="Assignment" E(S.unknown F.type="Assignment.Delete")')!;
-    expect(empty).toBeTruthy();
-  });
-
-  it('should parse nested existential condition', () => {
-    const { sql, parameters, factTypes, roleMap } = sqlFor('S.catalog F.type="ImprovingU.Idea" N(S.idea F.type="ImprovingU.Idea.Deletion" N(S.ideaDeletion F.type="ImprovingU.Idea.Restore"))')!;
-
-    expect(sql).toEqual(
-      'SELECT f2.hash as hash2 ' +
-      'FROM public.fact f1 ' +
-      'JOIN public.edge e1 ON e1.predecessor_fact_id = f1.fact_id AND e1.role_id = $3 ' +
-      'JOIN public.fact f2 ON f2.fact_id = e1.successor_fact_id ' +
-      'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
-      'AND NOT EXISTS (' +
-        'SELECT 1 ' +
-        'FROM public.edge e2 ' +
-        'WHERE e2.predecessor_fact_id = e1.successor_fact_id AND e2.role_id = $4 ' +
-        'AND NOT EXISTS (' +
-          'SELECT 1 ' +
-          'FROM public.edge e3 ' +
-          'WHERE e3.predecessor_fact_id = e2.successor_fact_id AND e3.role_id = $5' +
-        ')' +
-      ')');
-    expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Root'),
-      startHash,
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea'), 'catalog'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea.Deletion'), 'idea'),
-      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea.Restore'), 'ideaDeletion')
-    ]);
-  });
-});
-
-function allFactTypes(steps: Step[]): string[] {
-  const factTypes = steps
-    .filter(step => step instanceof PropertyCondition && step.name === 'type')
-    .map(step => (step as PropertyCondition).value);
-  const childFactTypes = steps
-    .filter(step => step instanceof ExistentialCondition)
-    .flatMap(step => allFactTypes((step as ExistentialCondition).steps));
-  return ["Root", ...factTypes, ...childFactTypes].filter(distinct);
-}
-
-function allRoles(steps: Step[], initialType: string) {
-  let roles: { type: string; role: string }[] = [];
-  let type: string | undefined = initialType;
-  let role: string | undefined = undefined;
-
-  for (const step of steps) {
-    if (step instanceof PropertyCondition) {
-      if (step.name === 'type') {
-        type = step.value;
-        if (role) {
-          if (type) {
-            roles.push({ type, role });
-          }
-          role = undefined;
-        }
-      }
-    }
-    else if (step instanceof Join) {
-      if (step.direction === Direction.Predecessor) {
-        if (type) {
-          roles.push({ type, role: step.role });
-        }
-        role = undefined;
-      }
-      else {
-        role = step.role;
-      }
-      type = undefined;
-    }
-    else if (step instanceof ExistentialCondition) {
-      if (type) {
-        roles = roles.concat(allRoles(step.steps, type));
-      }
-    }
-  }
-
-  return roles;
-}