next-data-kit 0.0.1

package/dist/react-data-kit-DmTzxNTc.d.cts

@@ -0,0 +1,225 @@
+/**
+ * react-data-kit - Database Types (Mongo)
+ *
+ * MongoDB-specific types.
+ * Consolidated into a single file for simplicity.
+ */
+/**
+ * Sort order for database queries
+ */
+type TSortOrder = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+/**
+ * ObjectId placeholder type - compatible with MongoDB ObjectId.
+ */
+type TObjectId = {
+    toString(): string;
+    toHexString(): string;
+    equals(otherId: TObjectId | string): boolean;
+};
+/**
+ * Generic document type that represents a database document with an ID.
+ */
+type TDocument<TId = unknown> = {
+    _id: TId;
+    createdAt?: Date;
+    updatedAt?: Date;
+};
+/**
+ * Mongo document base (includes common Mongo-only fields).
+ */
+type TMongoDocument = TDocument<string | TObjectId> & {
+    __v?: number;
+};
+/**
+ * Hydrated document type - represents a document with methods.
+ */
+type THydratedDocument<T, TId = unknown> = T & TDocument<TId>;
+/**
+ * Hydrated Mongo document.
+ */
+type TMongoHydratedDocument<T> = T & TMongoDocument & {
+    toObject(): T;
+    toJSON(): T;
+};
+/**
+ * Filter operators for individual fields (Mongo subset)
+ */
+type TMongoFilterOperators<T> = {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    $all?: T extends Array<infer U> ? U[] : never;
+    $elemMatch?: T extends Array<infer U> ? TMongoFilterQuery<U> : never;
+    $size?: number;
+    $regex?: string | RegExp;
+    $options?: string;
+    $type?: string | number;
+};
+/**
+ * Mongo root operators.
+ */
+type TMongoRootFilterOperators<T> = {
+    $and?: TMongoFilterQuery<T>[];
+    $or?: TMongoFilterQuery<T>[];
+    $nor?: TMongoFilterQuery<T>[];
+    $not?: TMongoFilterQuery<T>;
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $where?: string | ((this: T) => boolean);
+};
+/**
+ * Mongo filter query type.
+ */
+type TMongoFilterQuery<T> = {
+    [P in keyof T]?: T[P] | TMongoFilterOperators<T[P]>;
+} & TMongoRootFilterOperators<T>;
+/**
+ * Populate options for query builder.
+ */
+type TPopulateOptions = {
+    path: string;
+    select?: string | Record<string, 0 | 1>;
+    model?: string;
+    match?: Record<string, unknown>;
+    populate?: TPopulateOptions | TPopulateOptions[];
+};
+/**
+ * Query builder for chaining query operations.
+ */
+type TQueryBuilder<TResult, TQueryHelpers = object> = Promise<TResult> & {
+    sort(options: Record<string, TSortOrder>): TQueryBuilder<TResult, TQueryHelpers>;
+    limit(count: number): TQueryBuilder<TResult, TQueryHelpers>;
+    skip(count: number): TQueryBuilder<TResult, TQueryHelpers>;
+    select(fields: string | Record<string, 0 | 1>): TQueryBuilder<TResult, TQueryHelpers>;
+    populate(path: string | TPopulateOptions): TQueryBuilder<TResult, TQueryHelpers>;
+    lean(): TQueryBuilder<TResult, TQueryHelpers>;
+    exec(): Promise<TResult>;
+};
+/**
+ * Generic Model type.
+ */
+type TModel<TRawDocType = unknown, TQueryHelpers = object, TId = unknown, TFilter = unknown> = {
+    countDocuments(filter?: TFilter): Promise<number>;
+    find(filter?: TFilter): TQueryBuilder<TRawDocType[], TQueryHelpers>;
+    findOne(filter?: TFilter): TQueryBuilder<TRawDocType | null, TQueryHelpers>;
+    findById(id: TId): TQueryBuilder<TRawDocType | null, TQueryHelpers>;
+};
+/**
+ * Convenience alias for a Mongo-backed model.
+ */
+type TMongoModel<TRawDocType = unknown, TQueryHelpers = object> = TModel<TRawDocType, TQueryHelpers, string | TObjectId, TMongoFilterQuery<TRawDocType>>;
+/**
+ * Extract raw document type from a Model
+ */
+type TExtractDocType<M> = M extends TModel<infer TRawDocType, unknown, unknown, unknown> ? TRawDocType : never;
+/**
+ * Extract hydrated document type from a Model
+ */
+type TExtractHydratedDoc<M> = M extends TModel<infer TRawDocType, unknown, infer TId, unknown> ? THydratedDocument<TRawDocType, TId> : never;
+
+/**
+ * react-data-kit - React Data Kit Types
+ *
+ * Core types for the react-data-kit server action and components.
+ */
+
+/**
+ * Sort options type that references keys from the item type
+ */
+type TSortOptions<T> = {
+    [K in keyof T]?: TSortOrder;
+};
+/**
+ * Sort entry for array-based sorting
+ */
+type TSortEntry = {
+    path: string;
+    value: 1 | -1;
+};
+/**
+ * Filter configuration for automatic filtering
+ */
+type TFilterConfig = {
+    [key: string]: {
+        type: 'regex' | 'exact';
+        field?: string;
+    };
+};
+/**
+ * Custom filter configuration
+ * Allows defining custom filter functions for specific filter keys
+ */
+type TFilterCustomConfig<T = unknown> = {
+    [id: string]: (data: unknown) => TMongoFilterQuery<T>;
+};
+/**
+ * Variant of TFilterCustomConfig that allows customizing the returned filter shape.
+ * Useful for Mongo (operator-based) vs. other ORMs (where clauses) in the future.
+ */
+type TFilterCustomConfigWithFilter<TDoc = unknown, TFilter = TMongoFilterQuery<TDoc>> = {
+    [id: string]: (data: unknown) => TFilter;
+};
+/**
+ * React Data Kit server action input
+ */
+type TDataKitInput<T = unknown> = {
+    action?: 'FETCH';
+    page?: number;
+    limit?: number;
+    sort?: TSortOptions<T>;
+    sorts?: TSortEntry[];
+    query?: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+    filterConfig?: TFilterConfig;
+    filterCustom?: TFilterCustomConfig<T>;
+};
+/**
+ * React Data Kit server action result
+ */
+type TDataKitResult<R> = {
+    type: 'ITEMS';
+    items: R[];
+    documentTotal: number;
+};
+/**
+ * Pagination info for client-side use
+ */
+type TPaginationInfo = {
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+/**
+ * Calculate pagination info from react-data-kit result
+ */
+declare const calculatePagination: (page: number, limit: number, total: number) => TPaginationInfo;
+/**
+ * React Data Kit Adapter Interface
+ * Defines the contract for a database adapter.
+ */
+type TDataKitAdapter<T> = (params: Readonly<{
+    filter: Record<string, unknown>;
+    sorts: TSortEntry[];
+    limit: number;
+    page: number;
+    skip: number;
+    input: TDataKitInput<T>;
+}>) => Promise<{
+    items: T[];
+    total: number;
+}>;
+
+export { type TDataKitInput as T, type TDataKitAdapter as a, type TMongoModel as b, type TMongoFilterQuery as c, type TFilterCustomConfigWithFilter as d, type TSortOptions as e, type TDataKitResult as f, type TExtractDocType as g, type TModel as h, type THydratedDocument as i, type TSortOrder as j, type TFilterCustomConfig as k, type TFilterConfig as l, type TMongoFilterOperators as m, type TMongoRootFilterOperators as n, type TObjectId as o, type TMongoDocument as p, type TMongoHydratedDocument as q, type TSortEntry as r, type TDocument as s, type TQueryBuilder as t, type TPopulateOptions as u, type TExtractHydratedDoc as v, type TPaginationInfo as w, calculatePagination as x };

package/dist/react-data-kit-DmTzxNTc.d.ts

@@ -0,0 +1,225 @@
+/**
+ * react-data-kit - Database Types (Mongo)
+ *
+ * MongoDB-specific types.
+ * Consolidated into a single file for simplicity.
+ */
+/**
+ * Sort order for database queries
+ */
+type TSortOrder = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+/**
+ * ObjectId placeholder type - compatible with MongoDB ObjectId.
+ */
+type TObjectId = {
+    toString(): string;
+    toHexString(): string;
+    equals(otherId: TObjectId | string): boolean;
+};
+/**
+ * Generic document type that represents a database document with an ID.
+ */
+type TDocument<TId = unknown> = {
+    _id: TId;
+    createdAt?: Date;
+    updatedAt?: Date;
+};
+/**
+ * Mongo document base (includes common Mongo-only fields).
+ */
+type TMongoDocument = TDocument<string | TObjectId> & {
+    __v?: number;
+};
+/**
+ * Hydrated document type - represents a document with methods.
+ */
+type THydratedDocument<T, TId = unknown> = T & TDocument<TId>;
+/**
+ * Hydrated Mongo document.
+ */
+type TMongoHydratedDocument<T> = T & TMongoDocument & {
+    toObject(): T;
+    toJSON(): T;
+};
+/**
+ * Filter operators for individual fields (Mongo subset)
+ */
+type TMongoFilterOperators<T> = {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    $all?: T extends Array<infer U> ? U[] : never;
+    $elemMatch?: T extends Array<infer U> ? TMongoFilterQuery<U> : never;
+    $size?: number;
+    $regex?: string | RegExp;
+    $options?: string;
+    $type?: string | number;
+};
+/**
+ * Mongo root operators.
+ */
+type TMongoRootFilterOperators<T> = {
+    $and?: TMongoFilterQuery<T>[];
+    $or?: TMongoFilterQuery<T>[];
+    $nor?: TMongoFilterQuery<T>[];
+    $not?: TMongoFilterQuery<T>;
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $where?: string | ((this: T) => boolean);
+};
+/**
+ * Mongo filter query type.
+ */
+type TMongoFilterQuery<T> = {
+    [P in keyof T]?: T[P] | TMongoFilterOperators<T[P]>;
+} & TMongoRootFilterOperators<T>;
+/**
+ * Populate options for query builder.
+ */
+type TPopulateOptions = {
+    path: string;
+    select?: string | Record<string, 0 | 1>;
+    model?: string;
+    match?: Record<string, unknown>;
+    populate?: TPopulateOptions | TPopulateOptions[];
+};
+/**
+ * Query builder for chaining query operations.
+ */
+type TQueryBuilder<TResult, TQueryHelpers = object> = Promise<TResult> & {
+    sort(options: Record<string, TSortOrder>): TQueryBuilder<TResult, TQueryHelpers>;
+    limit(count: number): TQueryBuilder<TResult, TQueryHelpers>;
+    skip(count: number): TQueryBuilder<TResult, TQueryHelpers>;
+    select(fields: string | Record<string, 0 | 1>): TQueryBuilder<TResult, TQueryHelpers>;
+    populate(path: string | TPopulateOptions): TQueryBuilder<TResult, TQueryHelpers>;
+    lean(): TQueryBuilder<TResult, TQueryHelpers>;
+    exec(): Promise<TResult>;
+};
+/**
+ * Generic Model type.
+ */
+type TModel<TRawDocType = unknown, TQueryHelpers = object, TId = unknown, TFilter = unknown> = {
+    countDocuments(filter?: TFilter): Promise<number>;
+    find(filter?: TFilter): TQueryBuilder<TRawDocType[], TQueryHelpers>;
+    findOne(filter?: TFilter): TQueryBuilder<TRawDocType | null, TQueryHelpers>;
+    findById(id: TId): TQueryBuilder<TRawDocType | null, TQueryHelpers>;
+};
+/**
+ * Convenience alias for a Mongo-backed model.
+ */
+type TMongoModel<TRawDocType = unknown, TQueryHelpers = object> = TModel<TRawDocType, TQueryHelpers, string | TObjectId, TMongoFilterQuery<TRawDocType>>;
+/**
+ * Extract raw document type from a Model
+ */
+type TExtractDocType<M> = M extends TModel<infer TRawDocType, unknown, unknown, unknown> ? TRawDocType : never;
+/**
+ * Extract hydrated document type from a Model
+ */
+type TExtractHydratedDoc<M> = M extends TModel<infer TRawDocType, unknown, infer TId, unknown> ? THydratedDocument<TRawDocType, TId> : never;
+
+/**
+ * react-data-kit - React Data Kit Types
+ *
+ * Core types for the react-data-kit server action and components.
+ */
+
+/**
+ * Sort options type that references keys from the item type
+ */
+type TSortOptions<T> = {
+    [K in keyof T]?: TSortOrder;
+};
+/**
+ * Sort entry for array-based sorting
+ */
+type TSortEntry = {
+    path: string;
+    value: 1 | -1;
+};
+/**
+ * Filter configuration for automatic filtering
+ */
+type TFilterConfig = {
+    [key: string]: {
+        type: 'regex' | 'exact';
+        field?: string;
+    };
+};
+/**
+ * Custom filter configuration
+ * Allows defining custom filter functions for specific filter keys
+ */
+type TFilterCustomConfig<T = unknown> = {
+    [id: string]: (data: unknown) => TMongoFilterQuery<T>;
+};
+/**
+ * Variant of TFilterCustomConfig that allows customizing the returned filter shape.
+ * Useful for Mongo (operator-based) vs. other ORMs (where clauses) in the future.
+ */
+type TFilterCustomConfigWithFilter<TDoc = unknown, TFilter = TMongoFilterQuery<TDoc>> = {
+    [id: string]: (data: unknown) => TFilter;
+};
+/**
+ * React Data Kit server action input
+ */
+type TDataKitInput<T = unknown> = {
+    action?: 'FETCH';
+    page?: number;
+    limit?: number;
+    sort?: TSortOptions<T>;
+    sorts?: TSortEntry[];
+    query?: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+    filterConfig?: TFilterConfig;
+    filterCustom?: TFilterCustomConfig<T>;
+};
+/**
+ * React Data Kit server action result
+ */
+type TDataKitResult<R> = {
+    type: 'ITEMS';
+    items: R[];
+    documentTotal: number;
+};
+/**
+ * Pagination info for client-side use
+ */
+type TPaginationInfo = {
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+/**
+ * Calculate pagination info from react-data-kit result
+ */
+declare const calculatePagination: (page: number, limit: number, total: number) => TPaginationInfo;
+/**
+ * React Data Kit Adapter Interface
+ * Defines the contract for a database adapter.
+ */
+type TDataKitAdapter<T> = (params: Readonly<{
+    filter: Record<string, unknown>;
+    sorts: TSortEntry[];
+    limit: number;
+    page: number;
+    skip: number;
+    input: TDataKitInput<T>;
+}>) => Promise<{
+    items: T[];
+    total: number;
+}>;
+
+export { type TDataKitInput as T, type TDataKitAdapter as a, type TMongoModel as b, type TMongoFilterQuery as c, type TFilterCustomConfigWithFilter as d, type TSortOptions as e, type TDataKitResult as f, type TExtractDocType as g, type TModel as h, type THydratedDocument as i, type TSortOrder as j, type TFilterCustomConfig as k, type TFilterConfig as l, type TMongoFilterOperators as m, type TMongoRootFilterOperators as n, type TObjectId as o, type TMongoDocument as p, type TMongoHydratedDocument as q, type TSortEntry as r, type TDocument as s, type TQueryBuilder as t, type TPopulateOptions as u, type TExtractHydratedDoc as v, type TPaginationInfo as w, calculatePagination as x };

package/dist/server.cjs

@@ -0,0 +1,222 @@
+'use strict';
+
+// src/server/adapters/mongoose.ts
+var isProvided = (value) => value !== void 0 && value !== null && value !== "";
+var mongooseAdapter = (model, options = {}) => {
+  const { filter: customFilterFn, filterCustom, defaultSort = { _id: -1 } } = options;
+  return async ({ filter, sorts, limit, skip, input }) => {
+    let sortOption;
+    if (input.sort && Object.keys(input.sort).length > 0) {
+      sortOption = input.sort;
+    } else if (sorts && sorts.length > 0) {
+      sortOption = sorts.reduce((acc, s) => {
+        if (s?.path && (s.value === 1 || s.value === -1)) {
+          acc[s.path] = s.value;
+        }
+        return acc;
+      }, {});
+    } else {
+      sortOption = defaultSort;
+    }
+    let filterQuery = {};
+    if (input.query) {
+      Object.entries(input.query).forEach(([key, value]) => {
+        if (isProvided(value)) {
+          filterQuery[key] = value;
+        }
+      });
+    }
+    if (customFilterFn) {
+      const customQuery = customFilterFn(filter);
+      filterQuery = { ...filterQuery, ...customQuery };
+    }
+    if (filter && !customFilterFn) {
+      if (input.filterConfig) {
+        Object.entries(filter).forEach(([key, value]) => {
+          if (isProvided(value) && input.filterConfig?.[key]) {
+            const config = input.filterConfig[key];
+            const fieldName = config?.field ?? key;
+            if (config?.type === "regex") {
+              filterQuery[fieldName] = {
+                $regex: value,
+                $options: "i"
+              };
+            } else if (config?.type === "exact") {
+              filterQuery[fieldName] = value;
+            }
+          }
+        });
+      } else {
+        Object.entries(filter).forEach(([key, value]) => {
+          if (isProvided(value)) {
+            if (typeof value === "string") {
+              filterQuery[key] = {
+                $regex: value,
+                $options: "i"
+              };
+            } else {
+              filterQuery[key] = value;
+            }
+          }
+        });
+      }
+    }
+    if (filterCustom && filter) {
+      Object.entries(filter).forEach(([key, value]) => {
+        if (isProvided(value) && filterCustom[key]) {
+          const customFilter = filterCustom[key](value);
+          filterQuery = { ...filterQuery, ...customFilter };
+        }
+      });
+    }
+    const total = await model.countDocuments(filterQuery);
+    const items = await model.find(filterQuery).sort(sortOption).limit(limit).skip(skip);
+    return { items, total };
+  };
+};
+
+// src/server/action.ts
+var dataKitServerAction = async (props) => {
+  const { input, adapter, item, filter, filterCustom, defaultSort } = props;
+  const finalAdapter = typeof adapter === "function" ? adapter : mongooseAdapter(adapter, {
+    filter,
+    filterCustom,
+    defaultSort
+  });
+  switch (input.action ?? "FETCH") {
+    case "FETCH": {
+      if (!input.limit || !input.page) {
+        throw new Error("Invalid input: missing limit or page");
+      }
+      const limit = input.limit;
+      const skip = limit * (input.page - 1);
+      const { items, total } = await finalAdapter({
+        filter: input.filter ?? {},
+        sorts: input.sorts ?? [],
+        limit,
+        page: input.page,
+        skip,
+        input
+      });
+      const processedItems = await Promise.all(items.map((dataItem) => item(dataItem)));
+      return {
+        type: "ITEMS",
+        items: processedItems,
+        documentTotal: total
+      };
+    }
+    default:
+      throw new Error(`Unsupported action: ${input.action}`);
+  }
+};
+
+// src/server/adapters/memory.ts
+var isProvided2 = (value) => value !== void 0 && value !== null && value !== "";
+var getValueByPath = (obj, path) => {
+  if (!path) return void 0;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+};
+var matchesExact = (rowValue, needle) => {
+  if (Array.isArray(needle)) return needle.includes(rowValue);
+  return rowValue === needle;
+};
+var matchesRegexLike = (rowValue, needle) => {
+  if (!isProvided2(needle)) return true;
+  if (rowValue === void 0 || rowValue === null) return false;
+  const hay = String(rowValue);
+  if (needle instanceof RegExp) return needle.test(hay);
+  const n = String(needle);
+  return hay.toLowerCase().includes(n.toLowerCase());
+};
+var compareValues = (a, b) => {
+  if (a === b) return 0;
+  if (a === void 0 || a === null) return -1;
+  if (b === void 0 || b === null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "bigint" && typeof b === "bigint") return a < b ? -1 : 1;
+  const as = String(a);
+  const bs = String(b);
+  return as.localeCompare(bs);
+};
+var normalizeSorts = (sorts) => Array.isArray(sorts) ? sorts.filter((s) => !!s?.path && (s.value === 1 || s.value === -1)) : [];
+var adapterMemory = (dataset, options = {}) => {
+  const { defaultFilterType = "exact" } = options;
+  return async ({ filter, sorts, limit, skip, input }) => {
+    const filterConfig = input.filterConfig;
+    const query = input.query ?? {};
+    let rows = dataset.filter((row) => {
+      for (const [key, value] of Object.entries(query)) {
+        if (!isProvided2(value)) continue;
+        const rowValue = getValueByPath(row, key);
+        if (!matchesExact(rowValue, value)) return false;
+      }
+      return true;
+    });
+    const effectiveFilter = filter ?? {};
+    rows = rows.filter((row) => {
+      for (const [key, value] of Object.entries(effectiveFilter)) {
+        if (!isProvided2(value)) continue;
+        const config = filterConfig?.[key];
+        const field = config?.field ?? key;
+        const rowValue = getValueByPath(row, field);
+        const type = config?.type ?? defaultFilterType;
+        if (type === "regex") {
+          if (!matchesRegexLike(rowValue, value)) return false;
+        } else {
+          if (!matchesExact(rowValue, value)) return false;
+        }
+      }
+      return true;
+    });
+    const normalizedSorts = normalizeSorts(sorts);
+    if (normalizedSorts.length > 0) {
+      rows = [...rows].sort((ra, rb) => {
+        for (const s of normalizedSorts) {
+          const av = getValueByPath(ra, s.path);
+          const bv = getValueByPath(rb, s.path);
+          const cmp = compareValues(av, bv);
+          if (cmp !== 0) return s.value === 1 ? cmp : -cmp;
+        }
+        return 0;
+      });
+    }
+    const total = rows.length;
+    const items = rows.slice(skip, skip + limit);
+    return { items, total };
+  };
+};
+
+// src/server/utils.ts
+var escapeRegex = (str) => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+var createSearchFilter = (fields) => {
+  return (value) => {
+    if (!value || typeof value !== "string") {
+      return {};
+    }
+    const escapedValue = escapeRegex(value);
+    return {
+      $or: fields.map((field) => ({
+        [field]: { $regex: escapedValue, $options: "i" }
+      }))
+    };
+  };
+};
+
+exports.adapterMemory = adapterMemory;
+exports.createSearchFilter = createSearchFilter;
+exports.dataKitServerAction = dataKitServerAction;
+exports.escapeRegex = escapeRegex;
+exports.mongooseAdapter = mongooseAdapter;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map