Merge remote-tracking branch 'origin/main' into persist

Author: ddebrunner

dbquery/pings/postgresql/README.md

@@ -0,0 +1,64 @@
+# Ping PostgreSQL
+
+Simple schema that when deployed provides an easy way to check that a
+PostgreSQL database can be connected to from a GraphQL endpoint.
+
+## Setup
+
+Either set an environment variable or an `.env` file containing the URI of the PostgreSQL instance.
+
+Replace `<<xxx>>` values with the correct connection information.
+
+If a port number is required then add it to the host as `:1234`.
+
+If the password contains special characters then must be URL escaped.
+
+### Environment variable
+```
+export STEPZEN_PG_DB_URI=postgresql://<<host>>/<<database>>?user=<<user>>&password=<<password>>
+```
+
+### `.env` contents
+
+```
+STEPZEN_PG_DB_URI=postgresql://<<host>>/<<database>>?user=<<user>>&password=<<password>>
+```
+
+## Deploy
+
+```
+stepzen deploy
+```
+
+## Test
+
+```
+stepzen request '{ping{status}}'
+```
+
+## Example
+
+```
+>stepzen deploy 
+Deploying dbping/postgresql to StepZen... done in 443ms 🚀
+  ✓ 🔐 https://danville.us-east-a.ibm.stepzen.net/dbping/postgresql/__graphql
+  ✓ 🔐 wss://danville.us-east-a.ibm.stepzen.net/stepzen-subscriptions/dbping/postgresql/__graphql (subscriptions)
+
+You can test your hosted API with curl:
+
+curl https://danville.us-east-a.ibm.stepzen.net/dbping/postgresql/__graphql \
+   --header "Authorization: Apikey $(stepzen whoami --apikey)" \
+   --header "Content-Type: application/json" \
+   --data-raw '{
+     "query": "query SampleQuery { __schema { description queryType { fields {name} } } }"
+   }'
+
+stepzen request '{ping{status}}'
+{
+  "data": {
+    "ping": {
+      "status": "ok"
+    }
+  }
+}
+```

dbquery/pings/postgresql/config.yaml

@@ -0,0 +1,4 @@
+configurationset:
+  - configuration:
+      name: pgdb
+      uri: STEPZEN_PG_DB_URI

dbquery/pings/postgresql/index.graphql

@@ -0,0 +1,15 @@
+type Query {
+  """
+  Pings the configured database by running a SQL statement
+  that does not access any user tables or schema.
+  """
+  ping: Ping
+    @dbquery(
+      type: "postgresql"
+      query: "SELECT 'ok' AS status"
+      configuration: "pgdb"
+    )
+}
+type Ping {
+  status: String
+}

dbquery/pings/postgresql/stepzen.config.json

@@ -0,0 +1,3 @@
+{
+  "endpoint": "dbping/postgresql"
+}

dbquery/pings/postgresql/tests/Test.js

@@ -0,0 +1,12 @@
+const {
+  deployAndRun,
+  authTypes,
+  getTestDescription,
+} = require("../../../../tests/gqltest.js");
+
+testDescription = getTestDescription("snippets", __dirname);
+
+describe(testDescription, function () {
+  const tests = [];
+  return deployAndRun(__dirname, tests);
+});

protection/makeAllPublic/api.graphql

@@ -1,21 +1,22 @@
 type Customer {
-    name: String
-    city: String
+  name: String
+  city: String
 }
 type Query {
-    # An ecmascript generator of customer data.
-    # Of course, in real life you will call an API or a database. You can do that by changing the `endpoint` argument on the `@rest` directive. 
-    # https://stepzen.com/docs/connecting-backends/how-to-connect-a-rest-service
-    customer (id: ID): Customer
-    @rest (endpoint: "stepzen:empty"
-            ecmascript: """
-            function transformREST(s) {
-                var id = get('id')
-                if (id==1)
-                    return (JSON.stringify({"name":"John Doe","city":"Miami"}))
-                else
-                    return (JSON.stringify({"name":"Jane Smith","city":"Santa Clara"}))
-            }
-            """
+  # An ecmascript generator of customer data.
+  # Of course, in real life you will call an API or a database. You can do that by changing the `endpoint` argument on the `@rest` directive.
+  # https://stepzen.com/docs/connecting-backends/how-to-connect-a-rest-service
+  customer(id: ID!): Customer
+    @rest(
+      endpoint: "stepzen:empty"
+      ecmascript: """
+      function transformREST(s) {
+          var id = get('id')
+          if (id==1)
+              return (JSON.stringify({"name":"John Doe","city":"Miami"}))
+          else
+              return (JSON.stringify({"name":"Jane Smith","city":"Santa Clara"}))
+      }
+      """
     )
-}
+}

protection/makeAllPublic/operations.graphql

@@ -0,0 +1,6 @@
+query Customer($id: ID!) {
+  customer(id: $id) {
+    name
+    city
+  }
+}

protection/makeAllPublic/tests/Test.js

@@ -1,3 +1,5 @@
+const fs = require("fs");
+const path = require("node:path");
 const {
   deployAndRun,
   authTypes,
@@ -6,8 +8,42 @@ const {
 
 testDescription = getTestDescription("snippets", __dirname);
 
+const requestsFile = path.join(path.dirname(__dirname), "operations.graphql");
+const requests = fs.readFileSync(requestsFile, "utf8").toString();
+
 describe(testDescription, function () {
+  // note tests using no authorization since api is public
   const tests = [
-  ]
+    {
+      label: "customer-1",
+      query: requests,
+      operationName: "Customer",
+      variables: {
+        id: 1,
+      },
+      expected: {
+        customer: {
+          name: "John Doe",
+          city: "Miami",
+        },
+      },
+      authType: authTypes.noAuth,
+    },
+    {
+      label: "customer-2",
+      query: requests,
+      operationName: "Customer",
+      variables: {
+        id: 2,
+      },
+      expected: {
+        customer: {
+          name: "Jane Smith",
+          city: "Santa Clara",
+        },
+      },
+      authType: authTypes.noAuth,
+    },
+  ];
   return deployAndRun(__dirname, tests);
-});
+});

tests/README.md

@@ -8,7 +8,7 @@ Must have one environment variable set:
 
  * `STEPZEN_ENDPOINT` - StepZen endpoint all the tests will be deployed to (one at a time). For example:
    ```
-   export STEPZEN_ENDPOINT=https://YOUR_ACCOUNT.stepzen.net/test/snippets/graphql
+   export STEPZEN_ENDPOINT=https://YOUR_ACCOUNT.stepzen.net/test/snippets/__graphql
    ```
 
 You can also set this environment variable in a `.env` file in the `tests` folder. By copying the `.env.example` file.

tests/gqltest.js

@@ -1,10 +1,14 @@
 require("dotenv").config();
-const fetch = require("node-fetch");
-const { expect } = require("chai");
 const { execSync } = require("child_process");
 const { URL } = require("url");
 const path = require("node:path");
 
+const {
+  GQLHeaders,
+  executeOK,
+  logOnFail,
+} = require('gqltest/packages/gqltest/gqltest.js')
+
 const authTypes = {
   adminKey: 1,
   apiKey: 2,
@@ -15,10 +19,8 @@ Object.freeze(authTypes);
 
 // We use admin key to test because there is a cache optimization for apikey's that is not conducive
 // to rapid deploy and run cycles that occur with this type of testing
-const adminKey =
-  `apikey ` + execSync(`stepzen whoami --adminkey`).toString().trim();
-const apiKey =
-  `apikey ` + execSync(`stepzen whoami --apikey`).toString().trim();
+const adminKey = execSync(`stepzen whoami --adminkey`).toString().trim();
+const apiKey = execSync(`stepzen whoami --apikey`).toString().trim();
 
 const endpoint = process.env.STEPZEN_ENDPOINT;
 
@@ -45,50 +47,27 @@ function deployEndpoint(endpoint, dirname) {
 // as a test returning the response.
 // The test will fail if the request does not
 // have status 200 or has any GraphQL errors.
-function runGqlOk(authType, endpoint, documentId, query, variables, operationName) {
+async function runGqlOk(authType, endpoint, request, expected) {
+  let headers = new GQLHeaders();
   switch (authType) {
     case authTypes.adminKey:
-      authValue = adminKey;
+      headers.withAPIKey(adminKey);
       break;
     case authTypes.apiKey:
-      authValue = apiKey;
+      headers.withAPIKey(apiKey);
       break;
-    //  Have not  implemented jwt and noAuth yet
+    //  Have not  implemented jwt yet
     case authTypes.jwt:
     case authTypes.noAuth:
     default:
-      authValue = "";
   }
-  return fetch(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: authValue,
-    },
-    body: JSON.stringify({
-      documentId: documentId,
-      query: query,
-      variables: variables,
-      operationName: operationName,
-    }),
+ await executeOK({
+    test: this,
+    endpoint,
+    headers,
+    request,
+    expected,
   })
-    .then(function (result) {
-      expect(result.status).to.equal(200);
-      return result;
-    })
-    .then(function (result) {
-      return result.json();
-    })
-    .then(function (response) {
-      expect(response.errors, `no errors should exist: ${JSON.stringify(response.errors)}`).to.be.undefined;
-      return response;
-    });
-}
-
-// tests that the data key in a GraphQL response
-// is equal to value.
-function expectData(response, value) {
-  expect(response.data).to.eql(value);
 }
 
 // deploys graphql schema located in dirname to the test endpoint provided by the environment (process.env.STEPZEN_ENDPOINT),
@@ -102,20 +81,30 @@ function deployAndRun(dirname, tests) {
     return deployEndpoint(endpoint, dirname);
   });
 
+  afterEach('log-failure', logOnFail)
   tests.forEach(
     ({ label, documentId, query, variables, operationName, expected, authType }) => {
-      it(label, function () {
+      it(label, async function () {
         this.timeout(4000); // Occasional requests take > 2s
-        return runGqlOk(
+        let request = {}
+        if (query) {
+          request.query = query;
+        }
+        if (documentId) {
+          request.documentId = documentId;
+        }
+        if (operationName) {
+          request.operationName = operationName;
+        }
+        if (variables) {
+          request.variables = variables;
+        }
+        return await runGqlOk(
           authType,
           endpoint,
-          documentId,
-          query,
-          variables,
-          operationName
-        ).then(function (response) {
-          expectData(response, expected);
-        });
+          request,
+          expected,
+        );
       });
     }
   );
@@ -129,8 +118,6 @@ function getTestDescription(testRoot, fullDirName) {
   return segments.slice(rootIndex + 1, -1).join("/");
 }
 
-exports.runGqlOk = runGqlOk;
-exports.expectData = expectData;
 exports.deployAndRun = deployAndRun;
 exports.authTypes = authTypes;
 exports.getTestDescription = getTestDescription;