@elumixor/notion-orm 0.1.1 → 2.0.2

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,169 @@
+import type { CreatePageParameters, UpdatePageParameters } from "@notionhq/client/build/src/api-endpoints";
+import type { ZodTypeAny } from "zod";
+import type { FindManyArgs, 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: FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType> & {
+        stream: number;
+    }): AsyncIterable<Partial<DatabaseSchemaType> & {
+        id: string;
+    }>;
+    findMany<S extends Partial<Record<keyof DatabaseSchemaType, true>>>(args: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "select"> & {
+        select: S;
+    }): Promise<({
+        [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    })[]>;
+    findMany<O extends Partial<Record<keyof DatabaseSchemaType, true>>>(args: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "omit"> & {
+        omit: O;
+    }): Promise<({
+        [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    })[]>;
+    findMany(args?: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream">): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    })[]>;
+    /**
+     * 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: Omit<PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>, "select"> & {
+        select: S;
+    }): Promise<{
+        data: ({
+            [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+        } & {
+            id: string;
+        })[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    paginate<O extends Partial<Record<keyof DatabaseSchemaType, true>>>(args: Omit<PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>, "omit"> & {
+        omit: O;
+    }): Promise<{
+        data: ({
+            [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+        } & {
+            id: string;
+        })[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    paginate(args?: PaginateArgs<DatabaseSchemaType, ColumnNameToColumnType>): Promise<{
+        data: (Partial<DatabaseSchemaType> & {
+            id: string;
+        })[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    /** Find the first matching record, or null if none found. */
+    findFirst<S extends Partial<Record<keyof DatabaseSchemaType, true>>>(args: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "select"> & {
+        select: S;
+    }): Promise<({
+        [K in Extract<keyof S, keyof DatabaseSchemaType>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    }) | null>;
+    findFirst<O extends Partial<Record<keyof DatabaseSchemaType, true>>>(args: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream" | "omit"> & {
+        omit: O;
+    }): Promise<({
+        [K in Exclude<keyof DatabaseSchemaType, keyof O>]?: DatabaseSchemaType[K];
+    } & {
+        id: string;
+    }) | null>;
+    findFirst(args?: Omit<FindManyArgs<DatabaseSchemaType, ColumnNameToColumnType>, "stream">): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    }) | null>;
+    /** Find a record by its Notion page ID. Returns null if not found. */
+    findUnique(args: {
+        where: {
+            id: string;
+        };
+        select?: Partial<Record<keyof DatabaseSchemaType, true>>;
+        omit?: Partial<Record<keyof DatabaseSchemaType, true>>;
+    }): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    }) | null>;
+    /** Create a new record and return it. */
+    create(args: {
+        data: DatabaseSchemaType;
+        icon?: CreatePageParameters["icon"];
+    }): Promise<Partial<DatabaseSchemaType> & {
+        id: string;
+    }>;
+    /** Create multiple records and return them. */
+    createMany(args: {
+        data: DatabaseSchemaType[];
+        icon?: CreatePageParameters["icon"];
+    }): Promise<(Partial<DatabaseSchemaType> & {
+        id: string;
+    })[]>;
+    /** Update a record by its Notion page ID. */
+    update(args: {
+        where: {
+            id: string;
+        };
+        data: Partial<DatabaseSchemaType>;
+        icon?: UpdatePageParameters["icon"];
+    }): Promise<void>;
+    /** Update all records matching the filter. Returns the count of updated records. */
+    updateMany(args: {
+        where?: QueryFilter<DatabaseSchemaType, ColumnNameToColumnType>;
+        data: Partial<DatabaseSchemaType>;
+        icon?: UpdatePageParameters["icon"];
+    }): 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?: CreatePageParameters["icon"];
+    }): 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,6 +1,6 @@
 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
  */

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,33 @@ 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>>;
+    take?: number;
+    skip?: number;
+    /** When set, findMany returns an AsyncIterable, fetching results in batches of this size */
+    stream?: number;
+};
+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>>;
-    limit?: number;
-    pagination?: {
-        pageSize: number;
-    };
+    take?: number;
+    /** Opaque cursor token returned by a previous paginate() call */
+    after?: string;
 };
+/** @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;
 };

package/dist/index.js

@@ -3,15 +3,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -1327,7 +1341,7 @@ var require_src = __commonJS((exports) => {
   } });
 });
 
-// src/db-client/DatabaseClient.ts
+// src/db-client/client.ts
 var import_client = __toESM(require_src(), 1);
 
 // src/ast/constants.ts
@@ -1337,7 +1351,6 @@ var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
 var PACKAGE_ROOT = path.resolve(__dirname2, "../../");
 var IS_DEV = process.cwd() === PACKAGE_ROOT;
-var DATABASES_DIR = path.join(process.cwd(), "generated");
 var AST_RUNTIME_CONSTANTS = {
   NOTION_API_VERSION: "2025-09-03",
   PACKAGE_LOG_PREFIX: "[@elumixor/notion-orm]",
@@ -1346,6 +1359,16 @@ var AST_RUNTIME_CONSTANTS = {
   SCHEMA_DRIFT_HELP_MESSAGE: "Run `notion generate` to refresh all database schemas."
 };
 
+// src/helpers.ts
+function camelize(str) {
+  const cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
+  return cleaned.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
+    if (+match === 0)
+      return "";
+    return index === 0 ? match.toLowerCase() : match.toUpperCase();
+  });
+}
+
 // src/db-client/add.ts
 function buildPropertyValueForAddPage(args) {
   const { type, value } = args;
@@ -1441,16 +1464,6 @@ var emailCall = (args) => {
   return { email: value };
 };
 
-// src/helpers.ts
-function camelize(str) {
-  const cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-  return cleaned.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
-    if (+match === 0)
-      return "";
-    return index === 0 ? match.toLowerCase() : match.toUpperCase();
-  });
-}
-
 // src/db-client/query.ts
 function buildQueryResponse(res, camelPropertyNameToNameAndTypeMap, validateSchema) {
   const results = res.results.map((result, index) => {
@@ -1582,7 +1595,7 @@ function recursivelyBuildFilter(queryFilter, camelPropertyNameToNameAndTypeMap)
   }
 }
 
-// src/db-client/DatabaseClient.ts
+// src/db-client/client.ts
 class DatabaseClient {
   client;
   id;
@@ -1603,103 +1616,181 @@ class DatabaseClient {
     this.name = args.name;
     this.loggedSchemaValidationIssues = new Set;
   }
-  async add(args) {
-    const { properties: pageObject, icon } = args;
-    const callBody = {
-      parent: {
-        data_source_id: this.id,
-        type: "data_source_id"
-      },
-      properties: {}
-    };
-    callBody.icon = icon;
-    Object.entries(pageObject).forEach(([propertyName, value]) => {
-      const { type, columnName } = this.camelPropertyNameToNameAndTypeMap[propertyName];
-      const columnObject = buildPropertyValueForAddPage({
-        type,
-        value
-      });
-      if (callBody.properties && columnObject) {
-        callBody.properties[columnName] = columnObject;
-      }
+  findMany(args = {}) {
+    const queryCall = this.buildQueryCall(args);
+    if (args.stream)
+      return this.streamingIterable(queryCall, args);
+    return this.fetchAllPages(queryCall, args);
+  }
+  async paginate(args) {
+    const queryCall = this.buildQueryCall(args ?? {});
+    const response = await this.client.dataSources.query({
+      ...queryCall,
+      page_size: args?.take ?? 100,
+      start_cursor: args?.after
     });
-    return await this.client.pages.create(callBody);
+    const results = buildQueryResponse(response, this.camelPropertyNameToNameAndTypeMap, (r) => this.validateDatabaseSchema(r));
+    return {
+      data: this.applySelectOmit(results, args?.select, args?.omit),
+      nextCursor: response.has_more ? response.next_cursor ?? null : null,
+      hasMore: response.has_more
+    };
   }
-  async update(id, properties, icon) {
-    const callBody = { page_id: id, properties: {} };
-    if (icon !== undefined)
-      callBody.icon = icon;
-    Object.entries(properties).forEach(([propertyName, value]) => {
+  async findFirst(args) {
+    const queryCall = this.buildQueryCall(args ?? {});
+    const response = await this.client.dataSources.query({ ...queryCall, page_size: 1 });
+    const results = buildQueryResponse(response, this.camelPropertyNameToNameAndTypeMap, (r) => this.validateDatabaseSchema(r));
+    if (results.length === 0)
+      return null;
+    const [item] = this.applySelectOmit(results, args?.select, args?.omit);
+    return item ?? null;
+  }
+  async findUnique(args) {
+    try {
+      const page = await this.client.pages.retrieve({ page_id: args.where.id });
+      if (!("properties" in page))
+        return null;
+      const result = this.parsePage(page);
+      const [item] = this.applySelectOmit([result], args.select, args.omit);
+      return item ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async create(args) {
+    const callBody = this.buildCreateBody(args.data, args.icon);
+    const page = await this.client.pages.create(callBody);
+    return this.parsePage(page);
+  }
+  async createMany(args) {
+    return Promise.all(args.data.map((data) => this.create({ data, icon: args.icon })));
+  }
+  async update(args) {
+    const callBody = { page_id: args.where.id, properties: {} };
+    if (args.icon !== undefined)
+      callBody.icon = args.icon;
+    for (const [propertyName, value] of Object.entries(args.data)) {
       const { type, columnName } = this.camelPropertyNameToNameAndTypeMap[propertyName];
       const columnObject = buildPropertyValueForAddPage({ type, value });
-      if (callBody.properties && columnObject) {
+      if (callBody.properties && columnObject)
         callBody.properties[columnName] = columnObject;
-      }
-    });
+    }
     await this.client.pages.update(callBody);
   }
-  async delete(id) {
-    await this.client.pages.update({ page_id: id, archived: true });
+  async updateMany(args) {
+    const queryCall = this.buildQueryCall({ where: args.where });
+    const results = await this.fetchAllPages(queryCall, {});
+    await Promise.all(results.map((r) => this.update({ where: { id: r.id }, data: args.data, icon: args.icon })));
+    return { count: results.length };
   }
   async upsert(args) {
-    const queryCall = this.buildQueryCall({ filter: args.where });
+    const queryCall = this.buildQueryCall({ where: args.where });
     const response = await this.client.dataSources.query({ ...queryCall, page_size: 1 });
     if (response.results.length > 0) {
       const existingId = response.results[0].id;
-      await this.update(existingId, args.properties, args.icon);
+      await this.update({ where: { id: existingId }, data: args.update, icon: args.icon });
       return { created: false, id: existingId };
     }
-    const created = await this.add({ properties: args.properties, icon: args.icon });
+    const created = await this.create({ data: args.create, icon: args.icon });
     return { created: true, id: created.id };
   }
-  query(query) {
-    const queryCall = this.buildQueryCall(query);
-    if (query.pagination)
-      return this.paginatedIterable(queryCall, query);
-    return this.fetchAllPages(queryCall, query);
+  async delete(args) {
+    await this.client.pages.update({ page_id: args.where.id, archived: true });
+  }
+  async deleteMany(args) {
+    const queryCall = this.buildQueryCall({ where: args?.where });
+    const results = await this.fetchAllPages(queryCall, {});
+    await Promise.all(results.map((r) => this.delete({ where: { id: r.id } })));
+    return { count: results.length };
+  }
+  async count(args) {
+    const queryCall = this.buildQueryCall({ where: args?.where });
+    const results = await this.fetchAllPages(queryCall, {});
+    return results.length;
+  }
+  buildCreateBody(data, icon) {
+    const callBody = {
+      parent: { data_source_id: this.id, type: "data_source_id" },
+      properties: {}
+    };
+    if (icon)
+      callBody.icon = icon;
+    for (const [propertyName, value] of Object.entries(data)) {
+      const { type, columnName } = this.camelPropertyNameToNameAndTypeMap[propertyName];
+      const columnObject = buildPropertyValueForAddPage({ type, value });
+      if (callBody.properties && columnObject)
+        callBody.properties[columnName] = columnObject;
+    }
+    return callBody;
+  }
+  parsePage(page) {
+    const result = { id: page.id };
+    for (const [columnName, value] of Object.entries(page.properties)) {
+      const camelName = camelize(columnName);
+      const colType = this.camelPropertyNameToNameAndTypeMap[camelName]?.type;
+      if (colType)
+        result[camelName] = getResponseValue(colType, value);
+    }
+    return result;
   }
-  buildQueryCall(query) {
+  buildQueryCall(args) {
     const queryCall = { data_source_id: this.id };
-    if (query.sort?.length) {
-      queryCall["sorts"] = query.sort.map((s) => {
-        if (!("property" in s))
-          return s;
-        return { ...s, property: this.camelPropertyNameToNameAndTypeMap[s.property]?.columnName ?? s.property };
-      });
+    if (args.orderBy) {
+      const orderByArr = Array.isArray(args.orderBy) ? args.orderBy : [args.orderBy];
+      queryCall["sorts"] = orderByArr.flatMap((obj) => Object.entries(obj).map(([prop, dir]) => ({
+        property: this.camelPropertyNameToNameAndTypeMap[prop]?.columnName ?? prop,
+        direction: dir === "asc" ? "ascending" : "descending"
+      })));
     }
-    if (query.filter) {
-      queryCall["filter"] = recursivelyBuildFilter(query.filter, this.camelPropertyNameToNameAndTypeMap);
+    if (args.where) {
+      queryCall["filter"] = recursivelyBuildFilter(args.where, this.camelPropertyNameToNameAndTypeMap);
     }
     return queryCall;
   }
-  async fetchAllPages(queryCall, query) {
+  async fetchAllPages(queryCall, args) {
     const allResults = [];
     let cursor;
     let isFirst = true;
+    const take = args.take;
+    const skip = args.skip ?? 0;
+    let fetched = 0;
     do {
       const response = await this.client.dataSources.query({ ...queryCall, start_cursor: cursor, page_size: 100 });
       const page = buildQueryResponse(response, this.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => this.validateDatabaseSchema(r) : () => {});
       isFirst = false;
-      allResults.push(...this.applySelectOmit(page, query.select, query.omit));
+      for (const item of this.applySelectOmit(page, args.select, args.omit)) {
+        fetched++;
+        if (fetched <= skip)
+          continue;
+        allResults.push(item);
+        if (take && allResults.length >= take)
+          return allResults;
+      }
       cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
-    } while (cursor && (!query.limit || allResults.length < query.limit));
-    return query.limit ? allResults.slice(0, query.limit) : allResults;
+    } while (cursor);
+    return allResults;
   }
-  paginatedIterable(queryCall, query) {
+  streamingIterable(queryCall, args) {
     const self = this;
-    const pageSize = query.pagination.pageSize;
+    const pageSize = args.stream;
     return {
       [Symbol.asyncIterator]: async function* () {
         let cursor;
         let isFirst = true;
         let yielded = 0;
+        let skipped = 0;
+        const skip = args.skip ?? 0;
         do {
           const response = await self.client.dataSources.query({ ...queryCall, start_cursor: cursor, page_size: pageSize });
           const page = buildQueryResponse(response, self.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => self.validateDatabaseSchema(r) : () => {});
           isFirst = false;
-          for (const item of self.applySelectOmit(page, query.select, query.omit)) {
+          for (const item of self.applySelectOmit(page, args.select, args.omit)) {
+            if (skipped < skip) {
+              skipped++;
+              continue;
+            }
             yield item;
-            if (query.limit && ++yielded >= query.limit)
+            if (args.take && ++yielded >= args.take)
               return;
           }
           cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
@@ -1725,22 +1816,17 @@ class DatabaseClient {
     });
   }
   validateDatabaseSchema(result) {
-    if (!this.schema) {
+    if (!this.schema)
       return;
-    }
     const schemaLabel = this.name ?? this.id;
     const remoteColumnNames = new Set(Object.keys(result));
     const missingProperties = [];
     for (const propName in this.camelPropertyNameToNameAndTypeMap) {
-      if (!remoteColumnNames.has(propName)) {
+      if (!remoteColumnNames.has(propName))
         missingProperties.push(propName);
-      }
     }
     if (missingProperties.length > 0) {
-      const issueSignature2 = JSON.stringify({
-        type: "missing_properties",
-        properties: missingProperties
-      });
+      const issueSignature2 = JSON.stringify({ type: "missing_properties", properties: missingProperties });
       if (!this.loggedSchemaValidationIssues.has(issueSignature2)) {
         this.loggedSchemaValidationIssues.add(issueSignature2);
         console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
@@ -1756,10 +1842,7 @@ Missing properties: ${missingProperties.map((prop) => `\`${prop}\``).join(", ")}
       if (remoteColName === "id")
         continue;
       if (!this.camelPropertyNameToNameAndTypeMap[remoteColName]) {
-        const issueSignature2 = JSON.stringify({
-          type: "unexpected_property",
-          property: remoteColName
-        });
+        const issueSignature2 = JSON.stringify({ type: "unexpected_property", property: remoteColName });
         if (!this.loggedSchemaValidationIssues.has(issueSignature2)) {
           this.loggedSchemaValidationIssues.add(issueSignature2);
           console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
@@ -1773,17 +1856,11 @@ Unexpected property found in remote data: \`${remoteColName}\`
       }
     }
     const parseResult = this.schema.safeParse(result);
-    if (parseResult.success) {
+    if (parseResult.success)
       return;
-    }
-    const issueSignature = JSON.stringify(parseResult.error.issues.map((issue) => ({
-      code: issue.code,
-      path: issue.path,
-      message: issue.message
-    })));
-    if (this.loggedSchemaValidationIssues.has(issueSignature)) {
+    const issueSignature = JSON.stringify(parseResult.error.issues.map((issue) => ({ code: issue.code, path: issue.path, message: issue.message })));
+    if (this.loggedSchemaValidationIssues.has(issueSignature))
       return;
-    }
     this.loggedSchemaValidationIssues.add(issueSignature);
     console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
 			
@@ -1792,10 +1869,7 @@ Validation issues: ${parseResult.error.issues.map((issue) => `\`${issue.path.joi
 
 ✅ ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_HELP_MESSAGE}
 			`);
-    console.log("Validation details:", {
-      issues: parseResult.error.issues,
-      result
-    });
+    console.log("Validation details:", { issues: parseResult.error.issues, result });
   }
 }
 export {

package/dist/public-api.d.ts

@@ -2,6 +2,6 @@
  * Public API entry point for @elumixor/notion-orm.
  * External users' generated files import DatabaseClient and types from here.
  */
-export { DatabaseClient } from "./db-client/DatabaseClient";
-export type { Query, QueryResult, QueryResultType, SupportedNotionColumnType } from "./db-client/queryTypes";
+export { DatabaseClient } from "./db-client/client";
+export type { FindManyArgs, PaginateArgs, Query, QueryFilter, QueryResult, QueryResultType, OrderByInput, SupportedNotionColumnType, } from "./db-client/types";
 export type { NotionConfigType } from "./config/helpers";