@haustle/notion-orm 0.0.41 → 0.0.42

package/README.md

@@ -10,14 +10,20 @@
 A library to simplify interacting with [Notion](https://notion.so/product) databases/tables via Notion API
 
 ## Disclaimer
+### Available Database Features
+- Adding
+- Querying
 
-This library currently only supports databases that use the following column types
-
+### Supported Column Types
 - Multiselect
-- Text
 - Select
+- Status
+- Date
+- Text
 - Url
 - Checkbox
+- Email 
+- Phone Number
 
 # Install and Setup
 
@@ -38,8 +44,8 @@ The only requirement is a Notion Developer API Key ([here](https://developers.no
     const NotionConfig = {
     	auth: process.env.NOTION_KEY,
     	databaseIds: [
-    		"a52239e4839d4a3a8f4875376cfbfb02", 
-    		"5f4bf76a1e3f48d684d2506ea2690d64"
+    	    "a52239e4839d4a3a8f4875376cfbfb02", 
+    	    "5f4bf76a1e3f48d684d2506ea2690d64"
     	],
     };
     
@@ -72,8 +78,8 @@ Page title is required when adding
 
 ```tsx
 notion.books.add({
-	name: "Catcher in the Rye",
-	rating: "⭐️⭐️⭐️⭐️⭐️"
+    name: "Catcher in the Rye",
+    rating: "⭐️⭐️⭐️⭐️⭐️"
 })
 ```
 
@@ -83,11 +89,11 @@ notion.books.add({
 
 ```tsx
 notion.books.query({
-	filter: {
-		genre: {
-			contains: "Sci-Fi"
-		}
-	}
+    filter: {
+        genre: {
+            contains: "Sci-Fi"
+        }
+    }
 })
 ```
 
@@ -95,21 +101,21 @@ notion.books.query({
 
 ```tsx
 await notion.books.query({
-		filter: {
-			or: [
-				{
-					genre: {
-						contains: "Sci-Fi",
-					},
-				},
-				{
-					genre: {
-						contains: "Biography",
-					},
-				},
-			],
-		},
-	});
+    filter: {
+        or: [
+            {
+                genre: {
+                    contains: "Sci-Fi",
+                },
+            },
+            {
+                genre: {
+                    contains: "Biography",
+                },
+            },
+        ],
+    },
+});
 ```
 
 ## What is Object Relational Map (ORM)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haustle/notion-orm",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "tool to bring notion databases schemas/types to typescript",
   "main": "build/databases/index.js",
   "bin": {
@@ -20,5 +20,13 @@
   },
   "dependencies": {
     "@notionhq/client": "^2.2.2"
-  }
+  },
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Haustle/notion-orm"
+  },
+  "homepage": "https://github.com/Haustle/notion-orm#readme",
+  "keywords": ["notion orm", "typescript", "notion typesafety", "notion auto-complete", "notion databases", "notion-tables"]
+
 }

package/src/BuildCall.ts

@@ -0,0 +1,118 @@
+import { SupportedNotionColumnTypes } from "./queryTypes";
+
+export function getCall(args: {
+	type: SupportedNotionColumnTypes;
+	value: string | number | boolean;
+}) {
+	const { type, value } = args;
+	if (type === "select" && typeof value === "string") {
+		return selectCall({ value });
+	} else if (type === "multi_select" && Array.isArray(value)) {
+		return multiSelectCall({ value });
+	} else if (type === "status" && typeof value === "string") {
+		return statusCall({ option: value });
+	} else if (type === "number" && typeof value === "number") {
+		return numberCall({ value });
+	} else if (type === "email" && typeof value === "string") {
+		return emailCall({ value });
+	} else if (type === "date" && typeof value === "object") {
+		return dateCall({ value });
+	} else if (type === "phone_number" && typeof value === "string") {
+		return phoneNumberCall({ value });
+	} else if (type === "url" && typeof value === "string") {
+		return urlCall({ url: value });
+	} else if (type === "checkbox" && typeof value === "boolean") {
+		return checkboxCall({ checked: value });
+	} else if (type === "title" && typeof value === "string") {
+		return titleCall({ title: value });
+	} else if (type === "rich_text" && typeof value === "string") {
+		return textCall({ text: value });
+	} else {
+		console.error(
+			`'[@haustle/notion-orm] ${type}' column type currently not supported`
+		);
+	}
+}
+
+/* 
+======================================================
+GENERATE OBJECT BASED ON TYPE
+======================================================
+*/
+
+const selectCall = (args: { value: string }) => {
+	const { value } = args;
+	const select = {
+		name: value,
+	};
+	return { select };
+};
+
+const dateCall = (args: { value: { start: string; end?: string } }) => {
+	const { value } = args;
+	return { date: value };
+};
+const phoneNumberCall = (args: { value: string }) => {
+	const { value } = args;
+	return { phone_number: value };
+};
+
+const statusCall = (args: { option: string }) => {
+	const { option } = args;
+	const status = {
+		name: option,
+	};
+	return { status };
+};
+
+const multiSelectCall = (args: { value: Array<string> }) => {
+	const { value } = args;
+	const multi_select = value.map((option) => ({ name: option }));
+	return { multi_select };
+};
+
+const textCall = (args: { text: string }) => {
+	const { text } = args;
+	const rich_text = [
+		{
+			text: {
+				content: text,
+			},
+		},
+	];
+
+	return { rich_text };
+};
+
+const titleCall = (args: { title: string }) => {
+	const { title } = args;
+	const titleObject = [
+		{
+			text: {
+				content: title,
+			},
+		},
+	];
+
+	return { title: titleObject };
+};
+
+const numberCall = (args: { value: number }) => {
+	const { value: number } = args;
+	return { number };
+};
+
+const urlCall = (args: { url: string }) => {
+	const { url } = args;
+	return { url };
+};
+
+const checkboxCall = (args: { checked: boolean }) => {
+	const { checked: checkbox } = args;
+	return { checkbox };
+};
+
+const emailCall = (args: { value: string }) => {
+	const { value } = args;
+	return { email: value };
+};

package/src/DatabaseActions.ts

@@ -0,0 +1,140 @@
+import {
+	CreatePageParameters,
+	QueryDatabaseParameters,
+} from "@notionhq/client/build/src/api-endpoints";
+import { Client } from "@notionhq/client";
+import { getCall } from "./BuildCall";
+import path from "path";
+import { NotionConfigType } from "./index";
+import {
+	apiFilterType,
+	apiSingleFilter,
+	CompoundFilters,
+	Query,
+	QueryFilter,
+	SingleFilter,
+	SupportedNotionColumnTypes,
+} from "./queryTypes";
+
+export type propNameToColumnNameType = Record<
+	string,
+	{ columnName: string; type: SupportedNotionColumnTypes }
+>;
+
+// Import auth key from config file
+const { auth }: NotionConfigType = require(path.join(
+	process.cwd(),
+	"notion.config"
+));
+
+export class DatabaseActions<
+	DatabaseSchemaType extends Record<string, any>,
+	ColumnNameToColumnType extends Record<
+		keyof DatabaseSchemaType,
+		SupportedNotionColumnTypes
+	>
+> {
+	private NotionClient: Client = new Client({
+		auth,
+	});
+	private databaseId: string;
+	private propNameToColumnName: propNameToColumnNameType;
+	private columnNames: string[];
+
+	constructor(
+		datbaseId: string,
+		propNameToColumnName: propNameToColumnNameType
+	) {
+		this.databaseId = datbaseId;
+		this.propNameToColumnName = propNameToColumnName;
+		this.columnNames = Object.keys(propNameToColumnName);
+	}
+
+	// Add page to a database
+	async add(pageObject: DatabaseSchemaType) {
+		const callBody: CreatePageParameters = {
+			parent: {
+				database_id: this.databaseId,
+			},
+			properties: {},
+		};
+
+		const columnTypePropNames = Object.keys(pageObject);
+		columnTypePropNames.forEach((propName) => {
+			const { type, columnName } = this.propNameToColumnName[propName];
+			const columnObject = getCall({
+				type,
+				value: pageObject[propName],
+			});
+
+			callBody.properties[columnName] = columnObject!;
+		});
+
+		// console.log(JSON.stringify(callBody, null, 4));
+		await this.NotionClient.pages.create(callBody);
+	}
+
+	// Look for page inside the database
+	async query(query: Query<DatabaseSchemaType, ColumnNameToColumnType>) {
+		const queryCall: QueryDatabaseParameters = {
+			database_id: this.databaseId,
+		};
+
+		const filters = query.filter
+			? this.recursivelyBuildFilter(query.filter)
+			: undefined;
+		if (filters) {
+			// @ts-ignore errors vs notion api types
+			queryCall["filter"] = filters;
+		}
+
+		console.log(JSON.stringify(queryCall, null, 4));
+
+		const sort = query.sort;
+
+		const apiQuery = await this.NotionClient.databases.query(queryCall);
+		console.log(apiQuery);
+	}
+
+	private recursivelyBuildFilter(
+		queryFilter: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>
+	): apiFilterType {
+		// Need to loop because we don't kno
+		for (const prop in queryFilter) {
+			// if the filter is "and" || "or" we need to recursively
+			if (prop === "and" || prop === "or") {
+				const compoundFilters: QueryFilter<
+					DatabaseSchemaType,
+					ColumnNameToColumnType
+				>[] =
+					// @ts-ignore
+					queryFilter[prop];
+
+				const compoundApiFilters = compoundFilters.map(
+					(i: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>) => {
+						return this.recursivelyBuildFilter(i);
+					}
+				);
+
+				// Either have an `and` or an `or` compound filter
+				let temp: apiFilterType = {
+					...(prop === "and"
+						? { and: compoundApiFilters }
+						: { or: compoundApiFilters }),
+				};
+				return temp;
+			} else {
+				const propType = this.propNameToColumnName[prop].type;
+				const temp: apiSingleFilter = {
+					property: this.propNameToColumnName[prop].columnName,
+				};
+
+				//@ts-ignore
+				temp[propType] = (queryFilter as SingleFilter<ColumnNameToColumnType>)[
+					prop
+				];
+				return temp;
+			}
+		}
+	}
+}

package/src/GenerateTypes.ts

@@ -0,0 +1,421 @@
+import {
+	DatabaseObjectResponse,
+	GetDatabaseResponse,
+} from "@notionhq/client/build/src/api-endpoints";
+import * as ts from "typescript";
+import fs from "fs";
+import path from "path";
+import { DATABASES_DIR } from "./index";
+import { NotionColumnTypes } from "queryTypes";
+
+type propNameToColumnNameType = Record<
+	string,
+	{ columnName: string; type: NotionColumnTypes }
+>;
+
+/* 
+Responsible for generating `.ts` files
+*/
+export async function createTypescriptFileForDatabase(
+	dbResponse: GetDatabaseResponse
+) {
+	const {
+		id: databaseId,
+		properties,
+		title,
+	} = dbResponse as DatabaseObjectResponse;
+	const propNameToColumnName: propNameToColumnNameType = {};
+	const databaseName = title[0].plain_text;
+	const databaseClassName = camelize(databaseName).replace(/[^a-zA-Z0-9]/g, "");
+
+	const databaseColumnTypeProps: ts.TypeElement[] = [];
+
+	// Looping through each column of database
+	Object.values(properties).forEach((value) => {
+		const { type: columnType, name: columnName } = value;
+
+		// Taking the column name and camelizing it for typescript use
+		const camelizedColumnName = camelize(columnName);
+
+		// Creating map of column name to the column's name in the database's typescript type
+		propNameToColumnName[camelizedColumnName] = {
+			columnName,
+			type: columnType,
+		};
+
+		if (
+			columnType === "title" ||
+			columnType === "rich_text" ||
+			columnType === "email" ||
+			columnType === "phone_number"
+		) {
+			// add text column to collection type
+			databaseColumnTypeProps.push(
+				createTextProperty({
+					name: camelizedColumnName,
+					isTitle: columnType === "title",
+				})
+			);
+		} else if (columnType === "number") {
+			// add number column to collection type
+			databaseColumnTypeProps.push(createNumberProperty(camelizedColumnName));
+		} else if (columnType === "url") {
+			// add url column to collection type
+			databaseColumnTypeProps.push(
+				createTextProperty({ name: camelizedColumnName, isTitle: false })
+			);
+		} else if (columnType === "date") {
+			// add Date column to collection type
+			databaseColumnTypeProps.push(createDateProperty(camelizedColumnName));
+		} else if (
+			columnType === "select" ||
+			columnType === "status" ||
+			columnType === "multi_select"
+		) {
+			// @ts-ignore
+			const options = value[columnType].options.map((x) => x.name);
+			databaseColumnTypeProps.push(
+				createMultiOptionProp({
+					name: camelizedColumnName,
+					options,
+					isArray: columnType === "multi_select", // Union or Union Array
+				})
+			);
+		}
+	});
+
+	// Object type that represents the database schema
+	const DatabaseSchemaType = ts.factory.createTypeAliasDeclaration(
+		undefined,
+		ts.factory.createIdentifier("DatabaseSchemaType"),
+		undefined,
+		ts.factory.createTypeLiteralNode(databaseColumnTypeProps)
+	);
+
+	// Top level non-nested variable, functions, types for database files
+	const TsNodesForDatabaseFile = ts.factory.createNodeArray([
+		createDatabaseActionsClassImport(),
+		createDatabaseIdVariable(databaseId),
+		DatabaseSchemaType,
+		createColumnNameToColumnProperties(propNameToColumnName),
+		createColumnNameToColumnType(),
+		createDatabaseClassExport({ databaseName: databaseClassName }),
+	]);
+
+	const sourceFile = ts.createSourceFile(
+		"",
+		"",
+		ts.ScriptTarget.ESNext,
+		true,
+		ts.ScriptKind.TS
+	);
+	const printer = ts.createPrinter();
+
+	const typescriptCodeToString = printer.printList(
+		ts.ListFormat.MultiLine,
+		TsNodesForDatabaseFile,
+		sourceFile
+	);
+	const transpileToJavaScript = ts.transpile(typescriptCodeToString, {
+		module: ts.ModuleKind.None,
+		target: ts.ScriptTarget.ESNext,
+	});
+
+	// Create databases output folder
+	if (!fs.existsSync(DATABASES_DIR)) {
+		fs.mkdirSync(DATABASES_DIR);
+	}
+
+	// Create TypeScript and JavaScript files
+	fs.writeFileSync(
+		path.resolve(DATABASES_DIR, `${databaseClassName}.ts`),
+		typescriptCodeToString
+	);
+	fs.writeFileSync(
+		path.resolve(DATABASES_DIR, `${databaseClassName}.js`),
+		transpileToJavaScript
+	);
+
+	return { databaseName, databaseClassName, databaseId };
+}
+
+// generate text property
+function createTextProperty(args: { name: string; isTitle: boolean }) {
+	const { name, isTitle } = args;
+	const text = ts.factory.createPropertySignature(
+		undefined,
+		ts.factory.createIdentifier(name),
+		!isTitle ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+		ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+	);
+	return text;
+}
+
+/**
+ * Generate number property to go inside a type
+ * name: number
+ */
+function createNumberProperty(name: string) {
+	const number = ts.factory.createPropertySignature(
+		undefined,
+		ts.factory.createIdentifier(name),
+		ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+		ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+	);
+	return number;
+}
+
+/**
+ * For selects and multi-select collection properties
+ * array = true for multi-select
+ */
+function createMultiOptionProp(args: {
+	name: string;
+	options: string[];
+	isArray: boolean;
+}) {
+	const { isArray, name, options } = args;
+	return ts.factory.createPropertySignature(
+		undefined,
+		ts.factory.createIdentifier(name),
+		ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+		isArray
+			? ts.factory.createArrayTypeNode(
+					ts.factory.createParenthesizedType(
+						ts.factory.createUnionTypeNode([
+							...options.map((option) =>
+								ts.factory.createLiteralTypeNode(
+									ts.factory.createStringLiteral(option)
+								)
+							),
+							createOtherStringProp(),
+						])
+					)
+			  )
+			: ts.factory.createUnionTypeNode([
+					...options.map((option) =>
+						ts.factory.createLiteralTypeNode(
+							ts.factory.createStringLiteral(option)
+						)
+					),
+					createOtherStringProp(),
+			  ])
+	);
+}
+
+// string & {}. Allows users to pass in values
+function createOtherStringProp() {
+	return ts.factory.createIntersectionTypeNode([
+		ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+		ts.factory.createTypeLiteralNode([]),
+	]);
+}
+
+function createDateProperty(name: string) {
+	return ts.factory.createPropertySignature(
+		undefined,
+		ts.factory.createIdentifier(name),
+		ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+		ts.factory.createTypeLiteralNode([
+			ts.factory.createPropertySignature(
+				undefined,
+				ts.factory.createIdentifier("start"),
+				undefined,
+				ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+			),
+			ts.factory.createPropertySignature(
+				undefined,
+				ts.factory.createIdentifier("end"),
+				ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+				ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+			),
+		])
+	);
+}
+
+// Generate database Id variable
+// const databaseId = <database-id>
+function createDatabaseIdVariable(databaseId: string) {
+	return ts.factory.createVariableStatement(
+		undefined,
+		ts.factory.createVariableDeclarationList(
+			[
+				ts.factory.createVariableDeclaration(
+					ts.factory.createIdentifier("databaseId"),
+					undefined,
+					undefined,
+					ts.factory.createStringLiteral(databaseId)
+				),
+			],
+			ts.NodeFlags.Const
+		)
+	);
+}
+
+/**
+ * Instead of refering to the column names 1:1 such as "Book Rating", we transform them to
+ * camelcase (eg. bookRating). So we need to keep track of the original name and the type
+ * for when we construct request for API
+ *
+ * Example
+ *
+ * const columnNameToColumnProperties = {
+ *
+ *      "bookRating": {
+ *          columnName: "Book Rating",
+ *          type: "select"
+ *      },
+ *      "genre": {
+ *          columnName: "Genre",
+ *          type: "multi_select"
+ *      }
+ *
+ * }
+ */
+function createColumnNameToColumnProperties(colMap: propNameToColumnNameType) {
+	return ts.factory.createVariableDeclarationList(
+		[
+			ts.factory.createVariableDeclaration(
+				ts.factory.createIdentifier("columnNameToColumnProperties"),
+				undefined,
+				undefined,
+				ts.factory.createAsExpression(
+					ts.factory.createObjectLiteralExpression(
+						[
+							...Object.entries(colMap).map(([propName, value]) =>
+								ts.factory.createPropertyAssignment(
+									ts.factory.createStringLiteral(propName),
+									ts.factory.createObjectLiteralExpression(
+										[
+											ts.factory.createPropertyAssignment(
+												ts.factory.createIdentifier("columnName"),
+												ts.factory.createStringLiteral(value.columnName)
+											),
+											ts.factory.createPropertyAssignment(
+												ts.factory.createIdentifier("type"),
+												ts.factory.createStringLiteral(value.type)
+											),
+										],
+										true
+									)
+								)
+							),
+						],
+						true
+					),
+					ts.factory.createTypeReferenceNode(
+						ts.factory.createIdentifier("const"),
+						undefined
+					)
+				)
+			),
+		],
+		ts.NodeFlags.Const
+	);
+}
+
+function createColumnNameToColumnType() {
+	return ts.factory.createTypeAliasDeclaration(
+		undefined,
+		ts.factory.createIdentifier("ColumnNameToColumnType"),
+		undefined,
+		ts.factory.createMappedTypeNode(
+			undefined,
+			ts.factory.createTypeParameterDeclaration(
+				undefined,
+				ts.factory.createIdentifier("Property"),
+				ts.factory.createTypeOperatorNode(
+					ts.SyntaxKind.KeyOfKeyword,
+					ts.factory.createTypeQueryNode(
+						ts.factory.createIdentifier("columnNameToColumnProperties"),
+						undefined
+					)
+				),
+				undefined
+			),
+			undefined,
+			undefined,
+			ts.factory.createIndexedAccessTypeNode(
+				ts.factory.createIndexedAccessTypeNode(
+					ts.factory.createTypeQueryNode(
+						ts.factory.createIdentifier("columnNameToColumnProperties"),
+						undefined
+					),
+					ts.factory.createTypeReferenceNode(
+						ts.factory.createIdentifier("Property"),
+						undefined
+					)
+				),
+				ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("type"))
+			),
+			undefined
+			/* unknown */
+		)
+	);
+}
+
+// Need to import the database class used to execute database actions (adding + querying)
+function createDatabaseActionsClassImport() {
+	return ts.factory.createImportDeclaration(
+		undefined,
+		ts.factory.createImportClause(
+			false,
+			undefined,
+			ts.factory.createNamedImports([
+				ts.factory.createImportSpecifier(
+					false,
+					undefined,
+					ts.factory.createIdentifier("DatabaseActions")
+				),
+			])
+		),
+		ts.factory.createStringLiteral("../src/DatabaseActions"),
+		undefined
+	);
+}
+
+/**
+ * Create export statement for the database class
+ * export const <databaseName> = new DatabaseActions<DatabaseSchemaType>(datbaseId, columnNameToColumnProperties)
+ */
+function createDatabaseClassExport(args: { databaseName: string }) {
+	const { databaseName } = args;
+	return ts.factory.createVariableStatement(
+		[ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+		ts.factory.createVariableDeclarationList(
+			[
+				ts.factory.createVariableDeclaration(
+					ts.factory.createIdentifier(databaseName),
+					undefined,
+					undefined,
+					ts.factory.createNewExpression(
+						ts.factory.createIdentifier("DatabaseActions"),
+						[
+							ts.factory.createTypeReferenceNode(
+								ts.factory.createIdentifier("DatabaseSchemaType"),
+								undefined
+							),
+							ts.factory.createTypeReferenceNode(
+								ts.factory.createIdentifier("ColumnNameToColumnType"),
+								undefined
+							),
+						],
+						[
+							ts.factory.createIdentifier("databaseId"),
+							ts.factory.createIdentifier("columnNameToColumnProperties"),
+						]
+					)
+				),
+			],
+			ts.NodeFlags.Const
+		)
+	);
+}
+
+// for a type's property name
+function camelize(str: string) {
+	return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
+		if (+match === 0) return ""; // or if (/\s+/.test(match)) for white spaces
+		return index === 0 ? match.toLowerCase() : match.toUpperCase();
+	});
+}

package/src/cli.ts

@@ -0,0 +1,40 @@
+#! /usr/bin/env node
+
+import fs from "fs";
+import { createDatabaseTypes } from "./index";
+import path from "path";
+
+async function main() {
+	const args = process.argv.slice(2);
+
+	if (args.length === 1 && args[0] === "generate") {
+		const projDir = process.cwd();
+
+		const notionConfigDirJS = fs.existsSync(
+			path.join(projDir, "notion.config.js")
+		);
+		const notionConfigDirTS = fs.existsSync(
+			path.join(projDir, "notion.config.ts")
+		);
+
+		console.log(path.join(projDir, "notion.config"));
+		if (notionConfigDirJS || notionConfigDirTS) {
+			const config = require(path.join(projDir, "notion.config"));
+
+			const { databaseNames } = await createDatabaseTypes(config);
+			if (databaseNames.length < 0) {
+				console.log("generated no types");
+			} else {
+				console.log("Generated types for the following Database's: ");
+				for (let x = 0; x < databaseNames.length; x++) {
+					console.log(`${x}. ${databaseNames[x]}`);
+				}
+			}
+		} else {
+			console.error("Could not find file `notion.config.ts` in root");
+			process.exit(1);
+		}
+	}
+}
+
+main();

package/src/index.ts

@@ -0,0 +1,136 @@
+/**
+ * Responsible for consuming notion.config.js
+ */
+
+import { Client } from "@notionhq/client";
+import { GetDatabaseResponse } from "@notionhq/client/build/src/api-endpoints";
+import { createTypescriptFileForDatabase } from "./GenerateTypes";
+import * as ts from "typescript";
+import fs from "fs";
+import path from "path";
+
+export const DATABASES_DIR = path.join(__dirname, "../../build", "databases");
+
+export type NotionConfigType = {
+	auth: string;
+	databaseIds: string[];
+};
+
+export const createDatabaseTypes = async (args: NotionConfigType) => {
+	const { auth, databaseIds } = args;
+
+	// Making sure the user is passing valid arguments
+	if (!auth) {
+		console.error("Please pass a valid Notion Integration Key");
+		process.exit(1);
+	}
+
+	if (databaseIds.length < 0) {
+		console.error("Please pass some database Ids");
+		process.exit(1);
+	}
+
+	// Initialize client
+	const NotionClient = new Client({
+		auth: auth,
+	});
+
+	const databaseNames: string[] = [];
+	const databaseClassExportStatements: ts.ExportDeclaration[] = [];
+
+	// Remove the previous databases, so they can call get updated
+	fs.rmdir(DATABASES_DIR, () =>
+		console.log("Deleting current database types...")
+	);
+
+	for (const database_id of databaseIds) {
+		let dbOjbect: GetDatabaseResponse;
+
+		try {
+			// Get the database schema
+			dbOjbect = await NotionClient.databases.retrieve({
+				database_id,
+			});
+
+			// Create typescript file based on schema
+			const { databaseClassName, databaseId, databaseName } =
+				await createTypescriptFileForDatabase(dbOjbect);
+
+			databaseNames.push(databaseName);
+			databaseClassExportStatements.push(
+				databaseExportStatement({
+					databaseClassName,
+				})
+			);
+		} catch (e) {
+			console.error(e);
+			return { databaseNames: [] };
+		}
+	}
+
+	// Create a file that exports all databases
+	createDatabaseBarrelFile({
+		databaseClassExportStatements,
+	});
+	return { databaseNames };
+};
+
+// Create the export statement for database file file
+// export { databaseName } from "./databaseName"
+function databaseExportStatement(args: { databaseClassName: string }) {
+	const { databaseClassName } = args;
+	return ts.factory.createExportDeclaration(
+		undefined,
+		false,
+		ts.factory.createNamedExports([
+			ts.factory.createExportSpecifier(
+				false,
+				undefined,
+				ts.factory.createIdentifier(databaseClassName)
+			),
+		]),
+		ts.factory.createStringLiteral(`./${databaseClassName}`),
+		undefined
+	);
+}
+
+// Creates file that import all generated notion database Ids
+function createDatabaseBarrelFile(args: {
+	databaseClassExportStatements: ts.Node[];
+}) {
+	const { databaseClassExportStatements } = args;
+	const nodes = ts.factory.createNodeArray(databaseClassExportStatements);
+	const sourceFile = ts.createSourceFile(
+		"placeholder.ts",
+		"",
+		ts.ScriptTarget.ESNext,
+		true,
+		ts.ScriptKind.TS
+	);
+	const printer = ts.createPrinter();
+
+	const typescriptCodeToString = printer.printList(
+		ts.ListFormat.MultiLine,
+		nodes,
+		sourceFile
+	);
+
+	const transpileToJavaScript = ts.transpile(typescriptCodeToString, {
+		module: ts.ModuleKind.None,
+		target: ts.ScriptTarget.ES2015,
+	});
+
+	if (!fs.existsSync(DATABASES_DIR)) {
+		fs.mkdirSync(DATABASES_DIR);
+	}
+
+	// Create TypeScript and JavaScript file
+	fs.writeFileSync(
+		path.resolve(DATABASES_DIR, "index.ts"),
+		typescriptCodeToString
+	);
+	fs.writeFileSync(
+		path.resolve(DATABASES_DIR, "index.js"),
+		transpileToJavaScript
+	);
+}

package/src/queryTypes.ts

@@ -0,0 +1,169 @@
+/**
+ * Column types' for all query options
+ */
+// import { PageObjectResponse }
+
+import { PageObjectResponse } from "@notionhq/client/build/src/api-endpoints";
+
+type columnDiscriminatedUnionTypes = PageObjectResponse["properties"];
+export type NotionColumnTypes =
+	columnDiscriminatedUnionTypes[keyof columnDiscriminatedUnionTypes]["type"];
+// type SupportedQueryableNotionColumnTypes = Exclude<NotionColumnTypes, "created_by" | >
+
+export type SupportedNotionColumnTypes = Exclude<
+	NotionColumnTypes,
+	| "formula"
+	| "files"
+	| "people"
+	| "relation"
+	| "rollup"
+	| "created_by"
+	| "last_edited_by"
+	| "created_time"
+	| "last_edited_time"
+>;
+
+type TextPropertyFilters = {
+	equals: string;
+	does_not_equal: string;
+	contains: string;
+	does_not_contain: string;
+	starts_with: string;
+	ends_with: string;
+	is_empty: true;
+	is_not_empty: true;
+};
+
+type NumberPropertyFilters = {
+	equals: number;
+	does_not_equals: number;
+	greater_than: number;
+	less_than: number;
+	greater_than_or_equal_to: number;
+	less_than_or_equal_to: number;
+	is_empty: true;
+	is_not_empty: true;
+};
+
+type CheckBoxPropertyFilters = {
+	equals: boolean;
+	does_not_equal: boolean;
+};
+
+//
+type SelectPropertyFilters<T> = {
+	equals: (T extends Array<any> ? T[number] : T) | (string & {});
+	does_not_equal: (T extends Array<any> ? T[number] : T) | (string & {});
+	is_empty: true;
+	is_not_empty: true;
+};
+
+// pay in array --> need to turn into union
+type MultiSelectPropertyFilters<T> = {
+	contains: (T extends Array<any> ? T[number] : T) | (string & {});
+	does_not_contain: (T extends Array<any> ? T[number] : T) | (string & {});
+	is_empty: true;
+	is_not_empty: true;
+};
+
+type StatusPropertyFilters<T> = SelectPropertyFilters<T>;
+
+type ISO8601Date = string;
+type DatePropertyFilters = {
+	equals: ISO8601Date;
+	before: ISO8601Date;
+	after: ISO8601Date;
+	on_or_before: ISO8601Date;
+	is_empty: true;
+	is_not_empty: true;
+	on_or_after: string;
+	past_week: {};
+	past_month: {};
+	past_year: {};
+	this_week: {};
+	next_week: {};
+	next_month: {};
+	next_year: {};
+};
+
+export type FilterOptions<T = []> = {
+	rich_text: TextPropertyFilters;
+	title: TextPropertyFilters;
+	number: NumberPropertyFilters;
+	checkbox: CheckBoxPropertyFilters;
+	select: SelectPropertyFilters<T>;
+	multi_select: MultiSelectPropertyFilters<T>;
+	url: TextPropertyFilters;
+	date: DatePropertyFilters;
+	status: StatusPropertyFilters<T>;
+	email: TextPropertyFilters;
+	phone_number: TextPropertyFilters;
+};
+
+/**
+ * Types to build query object user types out
+ */
+
+type ColumnNameToNotionColumnType<T> = Record<
+	keyof T,
+	SupportedNotionColumnTypes
+>;
+type ColumnNameToPossibleValues = Record<string, any>;
+// T is a column name to column type
+// Y is the collection type
+export type SingleFilter<
+	Y extends Record<string, any>,
+	T extends ColumnNameToNotionColumnType<Y>
+> = {
+	// Passing the type from collection
+	[Property in keyof Y]?: Partial<FilterOptions<Y[Property]>[T[Property]]>;
+};
+
+export type CompoundFilters<
+	Y extends Record<string, any>,
+	T extends Record<keyof Y, SupportedNotionColumnTypes>
+> =
+	| { and: Array<SingleFilter<Y, T> | CompoundFilters<Y, T>> }
+	| { or: Array<SingleFilter<Y, T> | CompoundFilters<Y, T>> };
+
+export type QueryFilter<
+	Y extends Record<string, any>,
+	T extends Record<keyof Y, SupportedNotionColumnTypes>
+> = SingleFilter<Y, T> | CompoundFilters<Y, T>;
+
+export type Query<
+	Y extends Record<string, any>,
+	T extends Record<keyof Y, SupportedNotionColumnTypes>
+> = {
+	filter?: QueryFilter<Y, T>;
+	sort?: [];
+};
+
+export type apiFilterQuery = {
+	filter?: apiSingleFilter | apiAndFilter | apiOrFilter;
+};
+
+/**
+ * Transform the types above to build types to
+ * actually build schema for query request
+ */
+
+type apiColumnTypeToOptions = {
+	[prop in keyof FilterOptions]?: Partial<FilterOptions[prop]>;
+};
+export interface apiSingleFilter extends apiColumnTypeToOptions {
+	property: string;
+}
+
+export type apiFilterType =
+	| apiSingleFilter
+	| apiAndFilter
+	| apiOrFilter
+	| undefined;
+type apiAndFilter = {
+	and: Array<apiFilterType>;
+};
+
+type apiOrFilter = {
+	or: Array<apiFilterType>;
+};