@elumixor/notion-orm 0.1.1 → 2.1.0

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,18 +1464,8 @@ 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) {
+function buildQueryResponse(res, camelPropertyNameToNameAndTypeMap, validateSchema, meta) {
   const results = res.results.map((result, index) => {
     if (result.object === "page" && !("properties" in result)) {
       console.log("Skipping this page: ", { result });
@@ -1467,6 +1480,24 @@ function buildQueryResponse(res, camelPropertyNameToNameAndTypeMap, validateSche
         simpleResult[camelizeColumnName] = getResponseValue(columnType, result2);
       }
     }
+    if (meta?.$icon) {
+      const icon = result.icon;
+      if (icon?.type === "external")
+        simpleResult.$icon = icon.external?.url ?? null;
+      else if (icon?.type === "file")
+        simpleResult.$icon = icon.file?.url ?? null;
+      else
+        simpleResult.$icon = null;
+    }
+    if (meta?.$cover) {
+      const cover = result.cover;
+      if (cover?.type === "external")
+        simpleResult.$cover = cover.external?.url ?? null;
+      else if (cover?.type === "file")
+        simpleResult.$cover = cover.file?.url ?? null;
+      else
+        simpleResult.$cover = null;
+    }
     if (index === 0) {
       validateSchema(simpleResult);
     }
@@ -1582,7 +1613,7 @@ function recursivelyBuildFilter(queryFilter, camelPropertyNameToNameAndTypeMap)
   }
 }
 
-// src/db-client/DatabaseClient.ts
+// src/db-client/client.ts
 class DatabaseClient {
   client;
   id;
@@ -1603,103 +1634,201 @@ 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), { $icon: args?.$icon, $cover: args?.$cover });
+    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), { $icon: args?.$icon, $cover: args?.$cover });
+    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, { $icon: args.$icon, $cover: args.$cover });
+      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, args.$cover);
+    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, $cover: args.$cover })));
+  }
+  async update(args) {
+    const callBody = { page_id: args.where.id, properties: {} };
+    if (args.$icon !== undefined)
+      callBody.icon = { type: "external", external: { url: args.$icon } };
+    if (args.$cover !== undefined)
+      callBody.cover = { type: "external", external: { url: args.$cover } };
+    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, $cover: args.$cover })));
+    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, $cover: args.$cover });
       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, $cover: args.$cover });
     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 };
   }
-  buildQueryCall(query) {
+  async count(args) {
+    const queryCall = this.buildQueryCall({ where: args?.where });
+    const results = await this.fetchAllPages(queryCall, {});
+    return results.length;
+  }
+  buildCreateBody(data, $icon, $cover) {
+    const callBody = {
+      parent: { data_source_id: this.id, type: "data_source_id" },
+      properties: {}
+    };
+    if ($icon)
+      callBody.icon = { type: "external", external: { url: $icon } };
+    if ($cover)
+      callBody.cover = { type: "external", external: { url: $cover } };
+    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, meta) {
+    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);
+    }
+    if (meta?.$icon) {
+      if (page.icon?.type === "external")
+        result.$icon = page.icon.external?.url ?? null;
+      else if (page.icon?.type === "file")
+        result.$icon = page.icon.file?.url ?? null;
+      else
+        result.$icon = null;
+    }
+    if (meta?.$cover) {
+      if (page.cover?.type === "external")
+        result.$cover = page.cover.external?.url ?? null;
+      else if (page.cover?.type === "file")
+        result.$cover = page.cover.file?.url ?? null;
+      else
+        result.$cover = null;
+    }
+    return result;
+  }
+  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) : () => {});
+      const page = buildQueryResponse(response, this.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => this.validateDatabaseSchema(r) : () => {}, { $icon: args.$icon, $cover: args.$cover });
       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) : () => {});
+          const page = buildQueryResponse(response, self.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => self.validateDatabaseSchema(r) : () => {}, { $icon: args.$icon, $cover: args.$cover });
           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 +1854,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 +1880,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 +1894,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 +1907,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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elumixor/notion-orm",
-  "version": "0.1.1",
+  "version": "2.1.0",
   "type": "module",
   "description": "Bring Notion database schemas/types to TypeScript",
   "main": "dist/index.js",
@@ -29,6 +29,7 @@
   },
   "dependencies": {
     "@notionhq/client": "5.3.0",
+    "ora": "^9.3.0",
     "typescript": "^5.6.3",
     "zod": "^3.23.8"
   },

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

@@ -1,47 +0,0 @@
-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;
-}