Update endpoints to be fully typed. (makenotion#198)

Author: rhart92

.eslintrc.js

@@ -25,5 +25,6 @@ module.exports = {
         ignoreRestSiblings: true,
       },
     ],
+    "no-mixed-spaces-and-tabs": ["error", "smart-tabs"],
   },
 }

examples/generate-random-data/index.ts

@@ -1,34 +1,32 @@
 // Find the official Notion API client @ https://  github.com/makenotion/notion-sdk-js/
 // npm install @notionhq/client
 import { Client } from "@notionhq/client"
+import {
+  CreatePageBodyParameters,
+  CreatePageParameters,
+  GetDatabaseResponse,
+  GetPageResponse,
+} from "@notionhq/client/build/src/api-endpoints"
 
 import * as _ from "lodash"
 
 import { config } from "dotenv"
 config()
 
 import * as faker from "faker"
-import {
-  InputPropertyValueMap,
-  PropertyMap,
-} from "@notionhq/client/build/src/api-endpoints"
-import {
-  PropertyValueWithoutId,
-  SelectFilter,
-  TextFilter,
-  UserBase,
-} from "@notionhq/client/build/src/api-types"
 
 const notion = new Client({ auth: process.env["NOTION_KEY"] })
 
 const startTime = new Date()
+startTime.setSeconds(0, 0)
 
 // Given the properties of a database, generate an object full of
 // random data that can be used to generate new rows in our Notion database.
 function makeFakePropertiesData(
-  properties: PropertyMap
-): InputPropertyValueMap {
-  const propertyValues: InputPropertyValueMap = {}
+  properties: GetDatabaseResponse["properties"]
+): Record<string, CreatePageBodyParameters["properties"]> {
+  const propertyValues: Record<string, CreatePageBodyParameters["properties"]> =
+    {}
   Object.entries(properties).forEach(([name, property]) => {
     if (property.type === "date") {
       propertyValues[name] = {
@@ -117,15 +115,17 @@ function assertUnreachable(_x: never): never {
   throw new Error("Didn't expect to get here")
 }
 
-function userToString(userBase: UserBase) {
+function userToString(userBase: { id: string; name?: string | null }) {
   return `${userBase.id}: ${userBase.name || "Unknown Name"}`
 }
 
-function findRandomSelectColumnNameAndValue(properties: PropertyMap): {
+function findRandomSelectColumnNameAndValue(
+  properties: GetDatabaseResponse["properties"]
+): {
   name: string
   value: string | undefined
 } {
-  const options = Object.entries(properties).flatMap(([name, property]) => {
+  const options = _.flatMap(Object.entries(properties), ([name, property]) => {
     if (property.type === "select") {
       return [
         { name, value: _.sample(property.select.options.map(o => o.name)) },
@@ -141,7 +141,9 @@ function findRandomSelectColumnNameAndValue(properties: PropertyMap): {
   return { name: "", value: undefined }
 }
 
-function extractValueToString(property: PropertyValueWithoutId): string {
+function extractValueToString(
+  property: GetPageResponse["properties"][string]
+): string {
   switch (property.type) {
     case "checkbox":
       return property.checkbox.toString()
@@ -160,8 +162,14 @@ function extractValueToString(property: PropertyValueWithoutId): string {
     case "phone_number":
       return property.phone_number
     case "select":
+      if (!property.select) {
+        return ""
+      }
       return `${property.select.id} ${property.select.name}`
     case "multi_select":
+      if (!property.multi_select) {
+        return ""
+      }
       return property.multi_select
         .map(select => `${select.id} ${select.name}`)
         .join(", ")
@@ -183,27 +191,43 @@ function extractValueToString(property: PropertyValueWithoutId): string {
       } else if (property.formula.type === "number") {
         return property.formula.number?.toString() || "???"
       } else if (property.formula.type === "boolean") {
-        return property.formula.boolean.toString()
+        return property.formula.boolean?.toString() || "???"
       } else if (property.formula.type === "date") {
-        return new Date(property.formula.date.date.start).toISOString()
+        return (
+          (property.formula.date?.start &&
+            new Date(property.formula.date.start).toISOString()) ||
+          "???"
+        )
       } else {
         return assertUnreachable(property.formula)
       }
     case "rollup":
       if (property.rollup.type === "number") {
-        return property.rollup.number.toString()
+        return property.rollup.number?.toString() || "???"
       } else if (property.rollup.type === "date") {
-        return new Date(property.rollup.date.date.start).toISOString()
+        return (
+          (property.rollup.date?.start &&
+            new Date(property.rollup.date?.start).toISOString()) ||
+          "???"
+        )
       } else if (property.rollup.type === "array") {
         return JSON.stringify(property.rollup.array)
       } else {
         return assertUnreachable(property.rollup)
       }
+    case "relation":
+      if (property.relation) {
+        return property.relation.join(",")
+      }
+      return "???"
   }
   return assertUnreachable(property)
 }
 
-async function exerciseWriting(databaseId: string, properties: PropertyMap) {
+async function exerciseWriting(
+  databaseId: string,
+  properties: GetDatabaseResponse["properties"]
+) {
   console.log("\n\n********* Exercising Writing *********\n\n")
 
   const RowsToWrite = 10
@@ -212,18 +236,23 @@ async function exerciseWriting(databaseId: string, properties: PropertyMap) {
   for (let i = 0; i < RowsToWrite; i++) {
     const propertiesData = makeFakePropertiesData(properties)
 
-    await notion.pages.create({
+    const parameters: CreatePageParameters = {
       parent: {
         database_id: databaseId,
       },
       properties: propertiesData,
-    })
+    } as CreatePageParameters
+
+    await notion.pages.create(parameters)
   }
 
   console.log(`Wrote ${RowsToWrite} rows after ${startTime}`)
 }
 
-async function exerciseReading(databaseId: string, _properties: PropertyMap) {
+async function exerciseReading(
+  databaseId: string,
+  _properties: GetDatabaseResponse["properties"]
+) {
   console.log("\n\n********* Exercising Reading *********\n\n")
   // and read back what we just did
   const queryResponse = await notion.databases.query({
@@ -232,7 +261,7 @@ async function exerciseReading(databaseId: string, _properties: PropertyMap) {
   let numOldRows = 0
   queryResponse.results.map(page => {
     const createdTime = new Date(page.created_time)
-    if (createdTime <= startTime) {
+    if (startTime > createdTime) {
       numOldRows++
       return
     }
@@ -246,11 +275,14 @@ async function exerciseReading(databaseId: string, _properties: PropertyMap) {
     })
   })
   console.log(
-    `Skipped printing ${numOldRows} rows that were written before this test`
+    `Skipped printing ${numOldRows} rows that were written before ${startTime}`
   )
 }
 
-async function exerciseFilters(databaseId: string, properties: PropertyMap) {
+async function exerciseFilters(
+  databaseId: string,
+  properties: GetDatabaseResponse["properties"]
+) {
   console.log("\n\n********* Exercising Filters *********\n\n")
 
   // get a random select or multi-select column from the collection with a random value for it
@@ -264,7 +296,7 @@ async function exerciseFilters(databaseId: string, properties: PropertyMap) {
   console.log(`Looking for ${selectColumnName}=${selectColumnValue}`)
 
   // Check we can search by name
-  const queryFilterSelectFilterTypeBased: SelectFilter = {
+  const queryFilterSelectFilterTypeBased = {
     property: selectColumnName,
     select: { equals: selectColumnValue },
   }
@@ -288,14 +320,14 @@ async function exerciseFilters(databaseId: string, properties: PropertyMap) {
       "Need a rich_text column for this part of the test, could not find one"
     )
   }
-  const textColumnId = textColumn.id
+  const textColumnId = decodeURIComponent(textColumn.id)
   const letterToFind = faker.lorem.word(1)
 
   console.log(
-    `\n\nLooking for text column with id ${textColumnId} contains letter ${letterToFind}`
+    `\n\nLooking for text column with id "${textColumnId}" contains letter "${letterToFind}"`
   )
 
-  const textFilter: TextFilter = {
+  const textFilter = {
     property: textColumnId,
     text: { contains: letterToFind },
   }
@@ -307,7 +339,7 @@ async function exerciseFilters(databaseId: string, properties: PropertyMap) {
   })
 
   console.log(
-    `Had ${matchingTextResults.results.length} matching rows in column with ID ${textColumnId} containing letter ${letterToFind}`
+    `Had ${matchingTextResults.results.length} matching rows in column with ID "${textColumnId}" containing letter "${letterToFind}"`
   )
 }