@elumixor/notion-orm 0.1.1

package/dist/config/helpers.d.ts

@@ -0,0 +1,10 @@
+export type NotionConfigType = {
+    auth: string;
+    databases: Record<string, string>;
+};
+export declare function validateConfig(): Promise<void>;
+export declare function findConfigFile(): {
+    path: string;
+    isTS: true;
+} | undefined;
+export declare function initializeNotionConfigFile(): Promise<void>;

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,5 @@
+import type { NotionConfigType } from "./helpers";
+export declare function loadUserConfig(absolutePath: string): Promise<unknown>;
+export declare function loadConfig(configPath: string): Promise<NotionConfigType>;
+export declare function getNotionConfig(): Promise<NotionConfigType>;
+export declare function clearConfigCache(): void;

package/dist/db-client/DatabaseClient.d.ts

@@ -0,0 +1,47 @@
+import type { CreatePageParameters, CreatePageResponse, UpdatePageParameters } from "@notionhq/client/build/src/api-endpoints";
+import type { ZodTypeAny } from "zod";
+import type { Query, QueryFilter, QueryResultType, SupportedNotionColumnType } from "./queryTypes";
+export type camelPropertyNameToNameAndTypeMapType = Record<string, {
+    columnName: string;
+    type: SupportedNotionColumnType;
+}>;
+export declare class DatabaseClient<DatabaseSchemaType extends Record<string, any>, ColumnNameToColumnType extends Record<keyof DatabaseSchemaType, SupportedNotionColumnType>> {
+    private client;
+    private id;
+    private camelPropertyNameToNameAndTypeMap;
+    private schema;
+    name: string;
+    private loggedSchemaValidationIssues;
+    constructor(args: {
+        id: string;
+        camelPropertyNameToNameAndTypeMap: camelPropertyNameToNameAndTypeMapType;
+        auth: string;
+        name: string;
+        schema: ZodTypeAny;
+    });
+    add(args: {
+        properties: DatabaseSchemaType;
+        icon?: CreatePageParameters["icon"];
+    }): Promise<CreatePageParameters | CreatePageResponse>;
+    update(id: string, properties: Partial<DatabaseSchemaType>, icon?: UpdatePageParameters["icon"]): Promise<void>;
+    delete(id: string): Promise<void>;
+    upsert(args: {
+        where: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+        properties: DatabaseSchemaType;
+        icon?: CreatePageParameters["icon"];
+    }): Promise<{
+        created: boolean;
+        id: string;
+    }>;
+    query<Args extends Query<DatabaseSchemaType, ColumnNameToColumnType> & {
+        pagination: {
+            pageSize: number;
+        };
+    }>(query: Args): AsyncIterable<QueryResultType<DatabaseSchemaType, Args>>;
+    query<Args extends Omit<Query<DatabaseSchemaType, ColumnNameToColumnType>, "pagination">>(query: Args): Promise<QueryResultType<DatabaseSchemaType, Args>[]>;
+    private buildQueryCall;
+    private fetchAllPages;
+    private paginatedIterable;
+    private applySelectOmit;
+    private validateDatabaseSchema;
+}

package/dist/db-client/add.d.ts

@@ -0,0 +1,44 @@
+import { SupportedNotionColumnType } from "./queryTypes";
+export declare function buildPropertyValueForAddPage(args: {
+    type: SupportedNotionColumnType;
+    value: string | number | boolean;
+}): {
+    select: {
+        name: string;
+    };
+} | {
+    multi_select: {
+        name: string;
+    }[];
+} | {
+    status: {
+        name: string;
+    };
+} | {
+    number: number;
+} | {
+    email: string;
+} | {
+    date: {
+        start: string;
+        end?: string;
+    };
+} | {
+    phone_number: string;
+} | {
+    url: string;
+} | {
+    checkbox: boolean;
+} | {
+    title: {
+        text: {
+            content: string;
+        };
+    }[];
+} | {
+    rich_text: {
+        text: {
+            content: string;
+        };
+    }[];
+} | undefined;

package/dist/db-client/query.d.ts

@@ -0,0 +1,17 @@
+import type { QueryDataSourceResponse } from "@notionhq/client/build/src/api-endpoints";
+import type { apiFilterType, QueryFilter, SupportedNotionColumnType } from "./queryTypes";
+import type { camelPropertyNameToNameAndTypeMapType } from "./DatabaseClient";
+/**
+ * Transforms Notion API query response into simplified format
+ */
+export declare function buildQueryResponse<DatabaseSchemaType extends Record<string, any>>(res: QueryDataSourceResponse, camelPropertyNameToNameAndTypeMap: camelPropertyNameToNameAndTypeMapType, validateSchema: (result: Partial<DatabaseSchemaType>) => void): (Partial<DatabaseSchemaType> & {
+    id: string;
+})[];
+/**
+ * Extracts value from Notion property object based on column type
+ */
+export declare function getResponseValue(prop: SupportedNotionColumnType, x: Record<string, any>): any;
+/**
+ * Recursively converts user query filters to Notion API filter format
+ */
+export declare function recursivelyBuildFilter<DatabaseSchemaType extends Record<string, any>, ColumnNameToColumnType extends Record<keyof DatabaseSchemaType, SupportedNotionColumnType>>(queryFilter: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>, camelPropertyNameToNameAndTypeMap: camelPropertyNameToNameAndTypeMapType): apiFilterType;

package/dist/db-client/queryTypes.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Column types' for all query options
+ */
+import type { DataSourceObjectResponse, QueryDataSourceParameters } from "@notionhq/client/build/src/api-endpoints";
+type NotionPropertyTypeToConfigMap = DataSourceObjectResponse["properties"];
+export type DatabasePropertyType = NotionPropertyTypeToConfigMap[keyof NotionPropertyTypeToConfigMap]["type"];
+export declare const SUPPORTED_PROPERTY_TYPES: {
+    readonly files: false;
+    readonly people: false;
+    readonly rollup: true;
+    readonly created_by: false;
+    readonly last_edited_by: false;
+    readonly created_time: false;
+    readonly last_edited_time: false;
+    readonly formula: true;
+    readonly relation: true;
+    readonly url: true;
+    readonly phone_number: true;
+    readonly title: true;
+    readonly email: true;
+    readonly checkbox: true;
+    readonly date: true;
+    readonly multi_select: true;
+    readonly status: true;
+    readonly number: true;
+    readonly rich_text: true;
+    readonly select: true;
+    readonly unique_id: true;
+};
+export declare function isSupportedPropertyType(propertyType: DatabasePropertyType): propertyType is SupportedNotionColumnType;
+export type SupportedNotionColumnType = {
+    [K in keyof typeof SUPPORTED_PROPERTY_TYPES]: (typeof SUPPORTED_PROPERTY_TYPES)[K] extends true ? K : never;
+}[keyof typeof SUPPORTED_PROPERTY_TYPES];
+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;
+};
+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, SupportedNotionColumnType>;
+export type SingleFilter<Y extends Record<string, any>, T extends ColumnNameToNotionColumnType<Y>> = {
+    [Property in keyof Y]?: T[Property] extends keyof FilterOptions<Y[Property]> ? Partial<FilterOptions<Y[Property]>[T[Property]]> : never;
+};
+export type CompoundFilters<Y extends Record<string, any>, T extends Record<keyof Y, SupportedNotionColumnType>> = {
+    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, SupportedNotionColumnType>> = SingleFilter<Y, T> | CompoundFilters<Y, T>;
+export type Query<Y extends Record<string, any>, T extends Record<keyof Y, SupportedNotionColumnType>> = {
+    filter?: QueryFilter<Y, T>;
+    sort?: QueryDataSourceParameters["sorts"];
+    select?: Partial<Record<keyof Y, true>>;
+    omit?: Partial<Record<keyof Y, true>>;
+    limit?: number;
+    pagination?: {
+        pageSize: number;
+    };
+};
+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>;
+};
+export type QueryResult<DatabaseSchema> = Partial<DatabaseSchema> & {
+    id: string;
+};
+export type QueryResultType<Y, Args> = Args extends {
+    select: infer S extends Record<string, unknown>;
+} ? {
+    [K in Extract<keyof S, keyof Y>]?: Y[K];
+} & {
+    id: string;
+} : Args extends {
+    omit: infer O extends Record<string, unknown>;
+} ? {
+    [K in Exclude<keyof Y, keyof O>]?: Y[K];
+} & {
+    id: string;
+} : Partial<Y> & {
+    id: string;
+};
+export {};

package/dist/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function camelize(str: string): string;
+type Entries<T> = {
+    [K in keyof T]-?: [K, T[K]];
+}[keyof T][];
+export declare function objectEntries<T extends object>(obj: T): Entries<T>;
+export {};