Merge branch 'master' into landing/texts

Author: ragnorc

package-lock.json

@@ -44,6 +44,7 @@
     "cross-fetch": "3.1.4",
     "faunadb": "4.2.0",
     "graphql": "15.3.0",
+    "graphql-scalars": "^1.10.0",
     "graphql-tag": "2.11.0",
     "toucan-js": "2.5.0-beta.1",
     "uuid": "8.3.2"

packages/api/package-lock.json

@@ -3,13 +3,7 @@ import { Client, query as q } from "faunadb";
 import { getProjectSchema } from "../index";
 import { GraphQLSchema } from "graphql";
 import scaffold from "../fauna/scaffold";
-import {
-  OrganizationRepository,
-  ProjectRepository,
-  TableRespository,
-  ScalarFieldRepository,
-  RelationshipFieldRepository,
-} from "../fauna/repositories";
+import repositories from "../fauna/repositories";
 import { definitions } from "../definitions";
 
 jest.setTimeout(30000);
@@ -37,51 +31,73 @@ test("Integration Test", async () => {
   const test_client = new Client({
     secret,
   });
-  const Organization = new OrganizationRepository(test_client);
-  const Project = new ProjectRepository(test_client);
-  const Table = new TableRespository(test_client);
-  const ScalarField = new ScalarFieldRepository(test_client);
-  const RelationshipField = new RelationshipFieldRepository(test_client);
+
+  const { organization, project, table, scalarField, relationshipField } =
+    repositories(test_client);
   await scaffold(test_client);
 
-  const organizationId = await Organization.create({
+  const organizationId = await organization.create({
     name: "LibraryOrg",
     apiName: "LibraryOrg",
   });
-  const projectId = await Project.create({
+  expect(
+    organization.create({
+      name: "ABC",
+      apiName: "LibraryOrg",
+    })
+  ).rejects.toThrow(/already exists/);
+
+  const projectId = await project.create({
+    name: "WrongName",
+    apiName: "WrongApiName",
+    organizationId,
+  });
+  await project.update(projectId, {
     name: "LibraryProj",
     apiName: "LibraryProj",
     organizationId,
   });
 
+  expect(project.get(projectId)).resolves.toHaveProperty(
+    "apiName",
+    "LibraryProj"
+  );
+
   for (const [key, value] of Object.entries(tables)) {
-    tables[key].id = await Table.create({
+    tables[key].id = await table.create({
       ...value,
       projectId,
     });
   }
 
-  await ScalarField.create({
+  await scalarField.create({
     name: "title",
     apiName: "title",
     tableId: tables["Book"].id,
     type: "String",
   });
-  await ScalarField.create({
+  await scalarField.create({
     name: "name",
     apiName: "name",
     tableId: tables["Author"].id,
     type: "String",
   });
 
-  await RelationshipField.create({
-    name: "authors",
-    apiName: "authors",
-    backName: "books",
-    apiBackName: "books",
-    to: tables["Author"].id,
-    tableId: tables["Book"].id,
-  });
+  const [authorsFieldId, booksFieldId] =
+    await relationshipField.createBidirectional({
+      name: "authors",
+      apiName: "wrongAuthors",
+      backName: "books",
+      backApiName: "wrongBooks",
+      to: tables["Author"].id,
+      tableId: tables["Book"].id,
+    });
+
+  /**
+   * If the relationship fields do not update correctly then the GraphQL queries after will automatically fail
+   */
+  await relationshipField.update(authorsFieldId, { apiName: "authors" });
+  await relationshipField.update(booksFieldId, { apiName: "books" });
 
   const schema: GraphQLSchema = await getProjectSchema(test_client, projectId);
   const server = new ApolloServer({

packages/api/package.json

@@ -5,7 +5,7 @@ import { Table, FaunaSchema, RelationshipField } from "./types";
 
 const generateRelationQueries = (field: RelationshipField) => {
   const existingRelation = (id: string) =>
-    q.Match(q.Index("relationsUnique"), [
+    q.Match(q.Index("relations_unique"), [
       field.relationshipRef,
       field.relationKey === "A"
         ? q.Var("docRef")
@@ -20,36 +20,62 @@ const generateRelationQueries = (field: RelationshipField) => {
       if (!ids) return [];
       return ids.map((id: string) =>
         q.If(
-          q.IsEmpty(existingRelation(id)),
-          q.Create(q.Collection("relations"), {
-            data: {
+          q.Exists(
+            q.Ref(
               // @ts-ignore
-              relationshipRef: field.relationshipRef,
+              q.Collection(field.to.id),
               // @ts-ignore
-              [field.relationKey]: q.Var("docRef"),
-              // @ts-ignore
-              [field.relationKey === "A" ? "B" : "A"]: q.Ref(
+              id
+            )
+          ),
+          q.If(
+            q.IsEmpty(existingRelation(id)),
+            q.Create(q.Collection("relations"), {
+              data: {
                 // @ts-ignore
-                q.Collection(field.to.id),
+                relationshipRef: field.relationshipRef,
                 // @ts-ignore
-                id
-              ),
-            },
-          }),
-          q.Abort(`Object with id ${field.to.id} is already connected.`)
+                [field.relationKey]: q.Var("docRef"),
+                // @ts-ignore
+                [field.relationKey === "A" ? "B" : "A"]: q.Ref(
+                  // @ts-ignore
+                  q.Collection(field.to.id),
+                  // @ts-ignore
+                  id
+                ),
+              },
+            }),
+            q.Abort(`Object with id ${field.to.id} is already connected.`)
+          ),
+          q.Abort(
+            `Cannot connect object with id ${field.to.id} as it does not exist.`
+          )
         )
       );
     },
     disconnect: (ids: Array<string>) => {
       if (!ids) return [];
       return ids.map((id: string) =>
         q.If(
-          q.IsEmpty(existingRelation(id)),
-          q.Abort(`Object with id ${field.to.id} does not exist.`),
+          q.Exists(
+            q.Ref(
+              // @ts-ignore
+              q.Collection(field.to.id),
+              // @ts-ignore
+              id
+            )
+          ),
+          q.If(
+            q.IsEmpty(existingRelation(id)),
+            q.Abort(`Object with id ${field.to.id} was not connected.`),
 
-          q.Map(
-            q.Paginate(existingRelation(id)),
-            q.Lambda("X", q.Delete(q.Var("X")))
+            q.Map(
+              q.Paginate(existingRelation(id)),
+              q.Lambda("X", q.Delete(q.Var("X")))
+            )
+          ),
+          q.Abort(
+            `Cannot disconnect object with id ${field.to.id} as it does not exist.`
           )
         )
       );
@@ -82,8 +108,19 @@ export const definitions = (
         if (args.before) {
           options.before = q.Ref(q.Collection(table.id), args.before);
         }
+        let filter: boolean | Expr = true;
+        if (args.where?.title_eq) {
+          filter = q.Equals(
+            args.where.title_eq,
+            q.Select(["data", "294845251673129473"], q.Get(q.Var("ref")))
+          );
+        }
+
         return q.Map(
-          q.Paginate(q.Documents(q.Collection(table.id)), { ...options }),
+          q.Filter(
+            q.Paginate(q.Documents(q.Collection(table.id)), { ...options }),
+            q.Lambda("ref", filter)
+          ),
           q.Lambda("ref", q.Get(q.Var("ref")))
         );
       },