@haustle/notion-orm 0.0.2 → 0.0.4

package/src/NotionActions/NotionConfig.ts

@@ -1,150 +0,0 @@
-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";
-
-require("dotenv").config();
-
-export type NotionConfigType = {
-	auth: string;
-	databaseIds: string[];
-};
-
-type importClassType = {
-	databaseId: string;
-	databaseClassName: string;
-};
-
-export const createDatabaseTypes = async (notionInfo: NotionConfigType) => {
-	const { auth, databaseIds } = notionInfo;
-
-	// 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[] = [];
-
-	// retrieve the database object
-	const databaseClassImports: ts.ImportDeclaration[] = [];
-	const databaseCamelizedNames: string[] = [];
-
-	for (const database_id of databaseIds) {
-		let dbOjbect: GetDatabaseResponse;
-
-		// Try to get the database schema
-		try {
-			dbOjbect = await NotionClient.databases.retrieve({
-				database_id,
-			});
-		} catch (e) {
-			console.error(e);
-			return { databaseNames: [] };
-		}
-		const { databaseClassName, databaseId, databaseName } =
-			await createTypescriptFileForDatabase(dbOjbect);
-		databaseNames.push(databaseName);
-		databaseCamelizedNames.push(databaseClassName);
-
-		databaseClassImports.push(
-			databaseImportStatement({
-				databaseClassName,
-				databaseId,
-			})
-		);
-	}
-
-	const nodeArr = [
-		...databaseClassImports,
-		mainNotionVariable(databaseCamelizedNames),
-	];
-	createNotionFile(nodeArr);
-	return { databaseNames };
-};
-
-// Create the import statement for notion.ts file
-function databaseImportStatement(dbClass: importClassType) {
-	return ts.factory.createImportDeclaration(
-		undefined,
-		ts.factory.createImportClause(
-			false,
-			undefined,
-			ts.factory.createNamedImports([
-				ts.factory.createImportSpecifier(
-					false,
-					undefined,
-					ts.factory.createIdentifier(dbClass.databaseClassName)
-				),
-			])
-		),
-
-		// We've setup paths to allow @notion-database access
-		ts.factory.createStringLiteral(`@notion-database/${dbClass.databaseId}`),
-		undefined
-	);
-}
-
-function mainNotionVariable(databaseNames: string[]) {
-	return ts.factory.createVariableStatement(
-		[ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-		ts.factory.createVariableDeclarationList(
-			[
-				ts.factory.createVariableDeclaration(
-					ts.factory.createIdentifier("notion"),
-					undefined,
-					undefined,
-					ts.factory.createObjectLiteralExpression(
-						[
-							...databaseNames.map((name) =>
-								ts.factory.createShorthandPropertyAssignment(
-									ts.factory.createIdentifier(name),
-									undefined
-								)
-							),
-						],
-						true
-					)
-				),
-			],
-			ts.NodeFlags.Const
-		)
-	);
-}
-
-// Creates file that import all generated notion database Ids
-function createNotionFile(nodeArr: ts.Node[]) {
-	const nodes = ts.factory.createNodeArray(nodeArr);
-	const sourceFile = ts.createSourceFile(
-		"placeholder.ts",
-		"",
-		ts.ScriptTarget.ESNext,
-		true,
-		ts.ScriptKind.TS
-	);
-	const printer = ts.createPrinter();
-
-	const outputFile = printer.printList(
-		ts.ListFormat.MultiLine,
-		nodes,
-		sourceFile
-	);
-
-	const outputDir = path.join(__dirname, "../../src", "NotionActions");
-
-	if (!fs.existsSync(outputDir)) {
-		fs.mkdirSync(outputDir);
-	}
-	fs.writeFileSync(path.resolve(outputDir, "notion.ts"), outputFile);
-}

package/src/NotionActions/queryTypes.ts

@@ -1,141 +0,0 @@
-/**
- * Column types' for all query options
- */
-// import { PageObjectResponse }
-
-import { PageObjectResponse } from "@notionhq/client/build/src/api-endpoints";
-
-type columnDiscriminatedUnionTypes = PageObjectResponse["properties"];
-type NotionColumnTypes =
-	columnDiscriminatedUnionTypes[keyof columnDiscriminatedUnionTypes]["type"];
-
-export type FilterOptionNames =
-	| "text"
-	| "title"
-	| "number"
-	| "checkbox"
-	| "select"
-	| "multi_select"
-	| "url";
-
-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;
-};
-
-export type FilterOptions<T = []> = {
-	text: TextPropertyFilters;
-	title: TextPropertyFilters;
-	number: NumberPropertyFilters;
-	checkbox: CheckBoxPropertyFilters;
-	select: SelectPropertyFilters<T>;
-	multi_select: MultiSelectPropertyFilters<T>;
-	url: string;
-};
-
-/**
- * Types to build query object user types out
- */
-
-const x = {
-	character: "multi_select",
-};
-
-type ColumnNameToNotionColumnType<T> = Record<keyof T, FilterOptionNames>;
-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, FilterOptionNames>
-> =
-	| { 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, FilterOptionNames>
-> = SingleFilter<Y, T> | CompoundFilters<Y, T>;
-
-export type Query<
-	Y extends Record<string, any>,
-	T extends Record<keyof Y, FilterOptionNames>
-> = {
-	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>;
-};

package/src/index.ts

@@ -1,43 +0,0 @@
-#! /usr/bin/env node
-
-import fs from "fs";
-import { createDatabaseTypes } from "./NotionActions/NotionConfig";
-import path from "path";
-require("dotenv").config();
-
-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) {
-			// this is a relative import, so we can escape out
-
-			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/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-    "target": "es2016",                                 
-    "lib": ["es6"],                                      
-    "module": "commonjs",                                
-    "rootDir": "src",                                    
-    "resolveJsonModule": true,                           
-    "allowJs": true,                                     
-    "outDir": "build",                                    
-    "esModuleInterop": true,                             
-    "strict": true,      
-    "baseUrl": "src",                                
-    "noImplicitAny": true,
-    "paths": {
-      "@notion-database/*":["NotionActions/DatabaseTypes/*"]
-    }                               
-  },
-  "include": ["src/**/*", "src/NotionActions/DatabaseTypes"]
-}
-
-