@elumixor/notion-orm 0.1.1 → 2.1.0

package/dist/config/helpers.d.ts

@@ -1,10 +1,12 @@
 export type NotionConfigType = {
     auth: string;
     databases: Record<string, string>;
+    /** Output directory for generated files, relative to project root. Defaults to "generated/notion-orm" */
+    outputDir?: string;
 };
 export declare function validateConfig(): Promise<void>;
 export declare function findConfigFile(): {
     path: string;
     isTS: true;
 } | undefined;
-export declare function initializeNotionConfigFile(): Promise<void>;
+export declare function initializeNotionConfigFile(): Promise<"created" | "exists">;

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

@@ -1,4 +1,4 @@
-import { SupportedNotionColumnType } from "./queryTypes";
+import { SupportedNotionColumnType } from "./types";
 export declare function buildPropertyValueForAddPage(args: {
     type: SupportedNotionColumnType;
     value: string | number | boolean;

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

@@ -0,0 +1,175 @@
+import type { ZodTypeAny } from "zod";
+import type { FindManyArgs, IconCoverResult, PaginateArgs, QueryFilter, SupportedNotionColumnType } from "./types";
+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;
+    });
+    /** Find all matching records. When `stream` is set, returns an AsyncIterable fetching in batches of that size. */
+    findMany<Args extends FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType> & {
+        stream: number;
+    }>(args: Args): AsyncIterable<Partial<DatabaseSchemaType> & {
+        id: string;
+    } & IconCoverResult<Args>>;
+    findMany<S extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "select"> & {
+        select: S;
+    }>(args: Args): Promise<({
+        [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    } & IconCoverResult<Args>)[]>;
+    findMany<O extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "omit"> & {
+        omit: O;
+    }>(args: Args): Promise<({
+        [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    } & IconCoverResult<Args>)[]>;
+    findMany<Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream">>(args?: Args): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    } & IconCoverResult<Args>)[]>;
+    /**
+     * Fetch one page of results using Notion's native cursor.
+     * Pass the returned `nextCursor` as `after` on the next call to get the next page.
+     */
+    paginate<S extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>, "select"> & {
+        select: S;
+    }>(args: Args): Promise<{
+        data: ({
+            [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+        } & {
+            id: string;
+        } & IconCoverResult<Args>)[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    paginate<O extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>, "omit"> & {
+        omit: O;
+    }>(args: Args): Promise<{
+        data: ({
+            [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+        } & {
+            id: string;
+        } & IconCoverResult<Args>)[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    paginate<Args extends PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>>(args?: Args): Promise<{
+        data: (Partial<DatabaseSchemaType> & {
+            id: string;
+        } & IconCoverResult<Args>)[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    /** Find the first matching record, or null if none found. */
+    findFirst<S extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "select"> & {
+        select: S;
+    }>(args: Args): Promise<({
+        [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    } & IconCoverResult<Args>) | null>;
+    findFirst<O extends Partial<Record<keyof DatabaseSchemaType, true>>, Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "omit"> & {
+        omit: O;
+    }>(args: Args): Promise<({
+        [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    } & IconCoverResult<Args>) | null>;
+    findFirst<Args extends Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream">>(args?: Args): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    } & IconCoverResult<Args>) | null>;
+    /** Find a record by its Notion page ID. Returns null if not found. */
+    findUnique<Args extends {
+        where: {
+            id: string;
+        };
+        select?: Partial<Record<keyof DatabaseSchemaType, true>>;
+        omit?: Partial<Record<keyof DatabaseSchemaType, true>>;
+        $icon?: true;
+        $cover?: true;
+    }>(args: Args): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    } & IconCoverResult<Args>) | null>;
+    /** Create a new record and return it. */
+    create(args: {
+        data: DatabaseSchemaType;
+        $icon?: string;
+        $cover?: string;
+    }): Promise<Partial<DatabaseSchemaType> & {
+        id: string;
+    }>;
+    /** Create multiple records and return them. */
+    createMany(args: {
+        data: DatabaseSchemaType[];
+        $icon?: string;
+        $cover?: string;
+    }): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    })[]>;
+    /** Update a record by its Notion page ID. */
+    update(args: {
+        where: {
+            id: string;
+        };
+        data: Partial<DatabaseSchemaType>;
+        $icon?: string;
+        $cover?: string;
+    }): Promise<void>;
+    /** Update all records matching the filter. Returns the count of updated records. */
+    updateMany(args: {
+        where?: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+        data: Partial<DatabaseSchemaType>;
+        $icon?: string;
+        $cover?: string;
+    }): Promise<{
+        count: number;
+    }>;
+    /** Create or update a record. If a record matches `where`, updates it; otherwise creates it. */
+    upsert(args: {
+        where: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+        create: DatabaseSchemaType;
+        update: Partial<DatabaseSchemaType>;
+        $icon?: string;
+        $cover?: string;
+    }): Promise<{
+        created: boolean;
+        id: string;
+    }>;
+    /** Archive (soft-delete) a record by its Notion page ID. */
+    delete(args: {
+        where: {
+            id: string;
+        };
+    }): Promise<void>;
+    /** Archive all records matching the filter. Returns the count of deleted records. */
+    deleteMany(args?: {
+        where?: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+    }): Promise<{
+        count: number;
+    }>;
+    /** Count records matching the filter. */
+    count(args?: {
+        where?: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+    }): Promise<number>;
+    private buildCreateBody;
+    private parsePage;
+    private buildQueryCall;
+    private fetchAllPages;
+    private streamingIterable;
+    private applySelectOmit;
+    private validateDatabaseSchema;
+}

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

@@ -1,10 +1,13 @@
 import type { QueryDataSourceResponse } from "@notionhq/client/build/src/api-endpoints";
-import type { apiFilterType, QueryFilter, SupportedNotionColumnType } from "./queryTypes";
-import type { camelPropertyNameToNameAndTypeMapType } from "./DatabaseClient";
+import type { apiFilterType, QueryFilter, SupportedNotionColumnType } from "./types";
+import type { camelPropertyNameToNameAndTypeMapType } from "./client";
 /**
  * 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> & {
+export declare function buildQueryResponse<DatabaseSchemaType extends Record<string, any>>(res: QueryDataSourceResponse, camelPropertyNameToNameAndTypeMap: camelPropertyNameToNameAndTypeMapType, validateSchema: (result: Partial<DatabaseSchemaType>) => void, meta?: {
+    $icon?: true;
+    $cover?: true;
+}): (Partial<DatabaseSchemaType> & {
     id: string;
 })[];
 /**

package/dist/db-client/{queryTypes.d.ts → types.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Column types' for all query options
  */
-import type { DataSourceObjectResponse, QueryDataSourceParameters } from "@notionhq/client/build/src/api-endpoints";
+import type { DataSourceObjectResponse } from "@notionhq/client/build/src/api-endpoints";
 type NotionPropertyTypeToConfigMap = DataSourceObjectResponse["properties"];
 export type DatabasePropertyType = NotionPropertyTypeToConfigMap[keyof NotionPropertyTypeToConfigMap]["type"];
 export declare const SUPPORTED_PROPERTY_TYPES: {
@@ -111,16 +111,37 @@ export type CompoundFilters<Y extends Record<string, any>, T extends Record<keyo
     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"];
+/** Prisma-style orderBy: `{ fieldName: 'asc' | 'desc' }` or an array of those */
+export type OrderByInput<Y> = {
+    [K in keyof Y]?: "asc" | "desc";
+} | {
+    [K in keyof Y]?: "asc" | "desc";
+}[];
+export type FindManyArgs<Y extends Record<string, any>, T extends Record<keyof Y, SupportedNotionColumnType>> = {
+    where?: QueryFilter<Y, T>;
+    orderBy?: OrderByInput<Y>;
     select?: Partial<Record<keyof Y, true>>;
     omit?: Partial<Record<keyof Y, true>>;
-    limit?: number;
-    pagination?: {
-        pageSize: number;
-    };
-};
+    take?: number;
+    skip?: number;
+    /** When set, findMany returns an AsyncIterable, fetching results in batches of this size */
+    stream?: number;
+    $icon?: true;
+    $cover?: true;
+};
+export type PaginateArgs<Y extends Record<string, any>, T extends Record<keyof Y, SupportedNotionColumnType>> = {
+    where?: QueryFilter<Y, T>;
+    orderBy?: OrderByInput<Y>;
+    select?: Partial<Record<keyof Y, true>>;
+    omit?: Partial<Record<keyof Y, true>>;
+    take?: number;
+    /** Opaque cursor token returned by a previous paginate() call */
+    after?: string;
+    $icon?: true;
+    $cover?: true;
+};
+/** @deprecated Use FindManyArgs */
+export type Query<Y extends Record<string, any>, T extends Record<keyof Y, SupportedNotionColumnType>> = FindManyArgs<Y, T>;
 export type apiFilterQuery = {
     filter?: apiSingleFilter | apiAndFilter | apiOrFilter;
 };
@@ -144,6 +165,15 @@ type apiOrFilter = {
 export type QueryResult<DatabaseSchema> = Partial<DatabaseSchema> & {
     id: string;
 };
+export type IconCoverResult<Args> = (Args extends {
+    $icon: true;
+} ? {
+    $icon: string | null;
+} : unknown) & (Args extends {
+    $cover: true;
+} ? {
+    $cover: string | null;
+} : unknown);
 export type QueryResultType<Y, Args> = Args extends {
     select: infer S extends Record<string, unknown>;
 } ? {