@haustle/notion-orm 0.0.43 → 0.0.45

package/src/DatabaseActions.ts

@@ -1,227 +0,0 @@
-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

@@ -1,448 +0,0 @@
-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

@@ -1,40 +0,0 @@
-#! /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();