@haustle/notion-orm 0.0.41 → 0.0.43

package/src/DatabaseActions.ts

@@ -0,0 +1,227 @@
+import {
+	CreatePageParameters,
+	CreatePageResponse,
+	PageObjectResponse,
+	QueryDatabaseParameters,
+	QueryDatabaseResponse,
+} 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,
+	SimpleQueryResponse,
+	SingleFilter,
+	SupportedNotionColumnTypes,
+} from "./queryTypes";
+
+import { camelize } from "./GenerateTypes";
+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,
+		getCallBody?: boolean
+	): Promise<CreatePageParameters | CreatePageResponse> {
+		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!;
+		});
+
+		// CORS: If user wants the body of the call. Can then send to API
+		if (getCallBody) {
+			return callBody;
+		}
+
+		return await this.NotionClient.pages.create(callBody);
+	}
+
+	// Look for page inside the database
+	async query(
+		query: Query<DatabaseSchemaType, ColumnNameToColumnType>
+	): Promise<SimpleQueryResponse<DatabaseSchemaType>> {
+		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;
+		}
+
+		const sort = query.sort;
+
+		const response = await this.NotionClient.databases.query(queryCall);
+
+		return this.simplifyQueryResponse(response);
+	}
+
+	private simplifyQueryResponse(
+		res: QueryDatabaseResponse
+	): SimpleQueryResponse<DatabaseSchemaType> {
+		// Is this smart too do...idk
+		const rawResults = res.results as PageObjectResponse[];
+		const rawResponse = res;
+
+		const results: Partial<DatabaseSchemaType>[] = rawResults.map((result) => {
+			const simpleResult: Partial<DatabaseSchemaType> = {};
+			const properties = Object.entries(result.properties);
+
+			for (const [columnName, result] of properties) {
+				const camelizeColumnName = camelize(columnName);
+
+				const columnType = this.propNameToColumnName[camelizeColumnName].type;
+
+				// @ts-ignore
+				simpleResult[camelizeColumnName] = this.getResponseValue(
+					columnType,
+					result
+				);
+			}
+			return simpleResult;
+		});
+
+		return {
+			results,
+			rawResponse,
+		};
+	}
+
+	private getResponseValue(
+		prop: SupportedNotionColumnTypes,
+		x: Record<string, any>
+	) {
+		switch (prop) {
+			case "select": {
+				const { select } = x;
+				if (select) {
+					return select["name"];
+				}
+				return undefined;
+			}
+			case "title": {
+				const { title } = x;
+				if (title) {
+					const combinedText = title.map(
+						({ plain_text }: { plain_text: string }) => plain_text
+					);
+					return combinedText.join("");
+				}
+				return undefined;
+			}
+			case "url": {
+				const { url } = x;
+				return url;
+			}
+
+			case "multi_select": {
+				const { multi_select } = x;
+				if (multi_select) {
+					const multi_selectArr: string[] = multi_select.map(
+						({ name }: { name: string }) => name
+					);
+					return multi_selectArr;
+				}
+				return undefined;
+			}
+			default: {
+				return "lol";
+			}
+		}
+	}
+
+	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,448 @@
+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(
+		[ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+		ts.factory.createIdentifier("DatabaseSchemaType"),
+		undefined,
+		ts.factory.createTypeLiteralNode(databaseColumnTypeProps)
+	);
+
+	// Top level non-nested variable, functions, types for database files
+	const TsNodesForDatabaseFile = ts.factory.createNodeArray([
+		createNameImport({
+			namedImport: "DatabaseActions",
+			path: "../src/DatabaseActions",
+		}),
+		createNameImport({
+			namedImport: "Query",
+			path: "../src/queryTypes",
+		}),
+		createDatabaseIdVariable(databaseId),
+		DatabaseSchemaType,
+		createColumnNameToColumnProperties(propNameToColumnName),
+		createColumnNameToColumnType(),
+		createQueryTypeExport(),
+		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 createNameImport(args: { namedImport: string; path: string }) {
+	const { namedImport, path } = args;
+	return ts.factory.createImportDeclaration(
+		undefined,
+		ts.factory.createImportClause(
+			false,
+			undefined,
+			ts.factory.createNamedImports([
+				ts.factory.createImportSpecifier(
+					false,
+					undefined,
+					ts.factory.createIdentifier(namedImport)
+				),
+			])
+		),
+		ts.factory.createStringLiteral(path),
+		undefined
+	);
+}
+
+function createQueryTypeExport() {
+	return ts.factory.createTypeAliasDeclaration(
+		[ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+		ts.factory.createIdentifier("QuerySchemaType"),
+		undefined,
+		ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Query"), [
+			ts.factory.createTypeReferenceNode(
+				ts.factory.createIdentifier("DatabaseSchemaType"),
+				undefined
+			),
+			ts.factory.createTypeReferenceNode(
+				ts.factory.createIdentifier("ColumnNameToColumnType"),
+				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
+export 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();