@tulip-systems/core 0.8.3 → 0.9.0

package/dist/src/modules/data-tables/lib/filters/parsers.d.mts

@@ -0,0 +1,46 @@
+import z, { ZodEnum, ZodNullable, ZodType } from "zod";
+
+//#region src/modules/data-tables/lib/filters/parsers.d.ts
+type ParseFilter<TSchema extends z.ZodType> = {
+  schema: ZodNullable<TSchema>;
+  decode: (value: string) => z.input<TSchema>;
+  encode: (value: z.input<TSchema>) => string;
+  eq?: (a: z.output<TSchema>, b: z.output<TSchema>) => boolean;
+};
+/**
+ * Filter string
+ */
+type ParseFilterStringSchema = z.ZodString;
+declare const parseFilterString: <TSchema extends ParseFilterStringSchema>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter string array
+ */
+type ParseFilterArraySchema = z.ZodArray<ZodType>;
+declare const parseFilterArray: <TSchema extends ParseFilterArraySchema>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter enum
+ */
+type ParseFilterEnumSchema = ZodEnum;
+declare const parseFilterEnum: <TSchema extends ZodEnum>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter boolean value
+ */
+type ParseFilterBooleanSchema = z.ZodBoolean;
+declare const parseFilterBoolean: <TSchema extends z.ZodType<boolean>>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter datetime value
+ */
+type ParseFilterDatetimeSchema = z.ZodDate;
+declare const parseFilterDatetime: <TSchema extends ParseFilterDatetimeSchema>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter datetime range value (tuple of two dates)
+ */
+type ParseFilterDatetimeRangeSchema = z.ZodTuple<[z.ZodDate, z.ZodDate]>;
+declare const parseFilterDatetimeRange: <TSchema extends ParseFilterDatetimeRangeSchema>(schema: TSchema) => ParseFilter<TSchema>;
+/**
+ * Filter range value
+ */
+type ParseFilterTupleSchema = z.ZodTuple<[ZodType, ZodType]>;
+declare const parseFilterTuple: <TSchema extends ParseFilterTupleSchema>(schema: TSchema) => ParseFilter<TSchema>;
+//#endregion
+export { ParseFilter, ParseFilterArraySchema, ParseFilterBooleanSchema, ParseFilterDatetimeRangeSchema, ParseFilterDatetimeSchema, ParseFilterEnumSchema, ParseFilterStringSchema, ParseFilterTupleSchema, parseFilterArray, parseFilterBoolean, parseFilterDatetime, parseFilterDatetimeRange, parseFilterEnum, parseFilterString, parseFilterTuple };

package/dist/src/modules/data-tables/lib/filters/parsers.mjs

@@ -0,0 +1,47 @@
+//#region src/modules/data-tables/lib/filters/parsers.ts
+const parseFilterString = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => encoded?.trim() ?? null,
+	encode: (decoded) => decoded ?? ""
+});
+const parseFilterArray = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => encoded?.split(",").filter(Boolean) ?? [],
+	encode: (decoded) => decoded?.join(",") ?? ""
+});
+const parseFilterEnum = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => {
+		return encoded?.trim().toLowerCase();
+	},
+	encode: (decoded) => decoded
+});
+const parseFilterBoolean = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => {
+		return encoded?.trim().toLowerCase() === "true";
+	},
+	encode: (decoded) => decoded ? "true" : "false"
+});
+const parseFilterDatetime = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => encoded ? new Date(encoded) : null,
+	encode: (decoded) => decoded ? decoded.toISOString() : ""
+});
+const parseFilterDatetimeRange = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => {
+		if (!encoded) return null;
+		const [from, to] = encoded.split("_");
+		return from && to ? [new Date(from), new Date(to)] : null;
+	},
+	encode: (decoded) => decoded ? `${decoded[0].toISOString()}_${decoded[1].toISOString()}` : ""
+});
+const parseFilterTuple = (schema) => ({
+	schema: schema.nullable(),
+	decode: (encoded) => encoded?.split("_") ?? [],
+	encode: (decoded) => decoded?.join("_") ?? ""
+});
+
+//#endregion
+export { parseFilterArray, parseFilterBoolean, parseFilterDatetime, parseFilterDatetimeRange, parseFilterEnum, parseFilterString, parseFilterTuple };

package/dist/src/modules/data-tables/lib/filters/resolvers.d.mts

@@ -0,0 +1,28 @@
+import { TableFiltersDef } from "./config.mjs";
+import z from "zod";
+import * as nuqs_server0 from "nuqs/server";
+import { createParser } from "nuqs/server";
+
+//#region src/modules/data-tables/lib/filters/resolvers.d.ts
+/**
+ * Resolvers for nuqs search params
+ */
+declare function resolveFiltersSearchParams<TDef extends TableFiltersDef>(def: TDef): { readonly [K in keyof TDef]: ReturnType<typeof createParser<z.output<TDef[K]["schema"]>>> };
+/**
+ * Resolvers for zod schema
+ */
+declare function resolveFiltersSchema<TDef extends TableFiltersDef>(def: TDef): z.ZodObject<{ -readonly [P in keyof { [K in keyof TDef]: TDef[K]["schema"] }]: { [K in keyof TDef]: TDef[K]["schema"] }[P] }, z.core.$strip>;
+/**
+ * Resolvers for filter descriptors
+ */
+declare function resolveFilterDescriptors<TDef extends TableFiltersDef>(def: TDef): { [K in keyof TDef]: {
+  name: K;
+  parser: { readonly [K_1 in keyof TDef]: nuqs_server0.SingleParserBuilder<z.core.output<TDef[K_1]["schema"]>> }[K];
+} };
+/**
+ * Resolvers for the visibility state config
+ * @returns array of keys
+ */
+declare function resolveVisibilityState<TDef extends TableFiltersDef>(def: TDef): (keyof TDef)[];
+//#endregion
+export { resolveFilterDescriptors, resolveFiltersSchema, resolveFiltersSearchParams, resolveVisibilityState };

package/dist/src/modules/data-tables/lib/filters/resolvers.mjs

@@ -0,0 +1,55 @@
+import z from "zod";
+import { createParser } from "nuqs/server";
+
+//#region src/modules/data-tables/lib/filters/resolvers.ts
+/**
+* Resolvers for nuqs search params
+*/
+function resolveFiltersSearchParams(def) {
+	return typedFromEntries(typedEntries(def).map(([key, value]) => {
+		const codec = z.codec(z.string(), value.schema, {
+			decode: value.decode,
+			encode: value.encode
+		});
+		return [key, createParser({
+			parse: (query) => codec.parse(query),
+			serialize: (value) => codec.encode(value),
+			eq: value.eq
+		})];
+	}));
+}
+/**
+* Resolvers for zod schema
+*/
+function resolveFiltersSchema(def) {
+	const shape = typedFromEntries(typedEntries(def).map(([k, f]) => [k, f.schema]));
+	return z.object(shape);
+}
+/**
+* Resolvers for filter descriptors
+*/
+function resolveFilterDescriptors(def) {
+	return typedFromEntries(typedEntries(resolveFiltersSearchParams(def)).map(([key, parser]) => [key, {
+		name: key,
+		parser
+	}]));
+}
+/**
+* Resolvers for the visibility state config
+* @returns array of keys
+*/
+function resolveVisibilityState(def) {
+	return typedEntries(def).map(([key]) => key);
+}
+/**
+* Helpers
+*/
+function typedEntries(obj) {
+	return Object.entries(obj);
+}
+function typedFromEntries(entries) {
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+export { resolveFilterDescriptors, resolveFiltersSchema, resolveFiltersSearchParams, resolveVisibilityState };

package/dist/src/modules/data-tables/lib/helpers/create-column.mjs

@@ -0,0 +1,10 @@
+//#region src/modules/data-tables/lib/helpers/create-column.ts
+function createTableCell(column) {
+	return (newColumn) => ({
+		...column,
+		...newColumn
+	});
+}
+
+//#endregion
+export { createTableCell };

package/dist/src/modules/data-tables/lib/search-params.d.mts

@@ -0,0 +1,21 @@
+import * as nuqs from "nuqs";
+
+//#region src/modules/data-tables/lib/search-params.d.ts
+/**
+ * Searchparams
+ */
+declare const tableSearchParams: {
+  cursor: Omit<nuqs.SingleParserBuilder<number>, "parseServerSide"> & {
+    readonly defaultValue: number;
+    parseServerSide(value: string | string[] | undefined): number;
+  };
+  limit: Omit<nuqs.SingleParserBuilder<number>, "parseServerSide"> & {
+    readonly defaultValue: number;
+    parseServerSide(value: string | string[] | undefined): number;
+  };
+  sort: nuqs.SingleParserBuilder<string>;
+  order: nuqs.SingleParserBuilder<"asc" | "desc">;
+  search: nuqs.SingleParserBuilder<string>;
+};
+//#endregion
+export { tableSearchParams };

package/dist/src/modules/data-tables/lib/search-params.mjs

@@ -0,0 +1,16 @@
+import { parseAsIndex, parseAsInteger, parseAsString, parseAsStringLiteral } from "nuqs";
+
+//#region src/modules/data-tables/lib/search-params.ts
+/**
+* Searchparams
+*/
+const tableSearchParams = {
+	cursor: parseAsIndex.withDefault(0),
+	limit: parseAsInteger.withDefault(20),
+	sort: parseAsString,
+	order: parseAsStringLiteral(["asc", "desc"]),
+	search: parseAsString
+};
+
+//#endregion
+export { tableSearchParams };

package/dist/src/modules/data-tables/lib/types.d.mts

@@ -0,0 +1,54 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import { CommandDef } from "../../commands/lib/builder.mjs";
+import { UseQueryStatesKeysMap } from "nuqs";
+import { ColumnDef, PaginationState, RowSelectionState, SortingState, TableMeta, Updater } from "@tanstack/react-table";
+
+//#region src/modules/data-tables/lib/types.d.ts
+/**
+ * Data table meta
+ */
+type TableMetaInput<TData> = TableMeta<TData>;
+type TableMeta$1<TData, TMeta = TableMetaInput<TData>> = {
+  strategy: TableStrategy;
+  selectedData: TData[];
+  commands?: CommandDef[];
+};
+/**
+ * Table column definition
+ */
+type TableColumnDef<TData> = ColumnDef<TData> & {
+  permissions?: Permission;
+  meta?: TableColumnMeta;
+};
+/**
+ * Data table strategy
+ */
+type TableStrategy = {
+  name: "pagination" | "infinite";
+  rowCount?: number;
+  paginationState?: PaginationState;
+  manualPagination?: boolean;
+  onPaginationChange?: (updater: Updater<PaginationState>) => PaginationState;
+  resetCursor: () => number | null;
+  tableSearchParams: UseQueryStatesKeysMap;
+  sortingState: SortingState;
+  manualSorting: boolean;
+  onSortingChange: (updater: Updater<SortingState>) => SortingState;
+  meta?: object;
+};
+/**
+ * Data table meta
+ */
+type TableColumnMeta = object;
+/**
+ * Data table selection
+ */
+type Selection = {
+  rowSelection: RowSelectionState;
+  setRowSelection: (row: Updater<RowSelectionState>) => void;
+} | {
+  rowSelection?: undefined;
+  setRowSelection?: undefined;
+};
+//#endregion
+export { Selection, TableColumnDef, TableColumnMeta, TableMeta$1 as TableMeta, TableMetaInput, TableStrategy };

package/dist/src/modules/data-tables/lib/validators.d.mts

@@ -0,0 +1,19 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/data-tables/lib/validators.d.ts
+/**
+ * Server data table query schema
+ */
+declare const tableQuerySchema: z$1.ZodObject<{
+  cursor: z$1.ZodPipe<z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCoercedNumber<unknown>>>, z$1.ZodTransform<number, number>>;
+  limit: z$1.ZodPipe<z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCoercedNumber<unknown>>>, z$1.ZodTransform<number, number>>;
+  sort: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  order: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>>;
+  search: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+}, z$1.core.$strip>;
+type TableQuerySchema = z$1.infer<typeof tableQuerySchema>;
+//#endregion
+export { TableQuerySchema, tableQuerySchema };

package/dist/src/modules/data-tables/lib/validators.mjs

@@ -0,0 +1,16 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/data-tables/lib/validators.ts
+/**
+* Server data table query schema
+*/
+const tableQuerySchema = z$1.object({
+	cursor: z$1.coerce.number().optional().default(0).transform((val) => Math.max(val, 0)),
+	limit: z$1.coerce.number().optional().default(10).transform((val) => Math.min(Math.max(val, 1), 1e3)),
+	sort: z$1.string().nullable().optional(),
+	order: z$1.enum(["asc", "desc"]).nullable().optional(),
+	search: z$1.string().nullable().optional()
+});
+
+//#endregion
+export { tableQuerySchema };

package/dist/src/modules/data-tables/server/get-data.server.d.mts

@@ -0,0 +1,29 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { TulipContext } from "../../config/lib/context.mjs";
+import "../../../../config.mjs";
+import { TableQuerySchema } from "../lib/validators.mjs";
+import { ConvertSearchToQueryParamsFields } from "../lib/converters/search.mjs";
+import { PgTable } from "drizzle-orm/pg-core";
+import "server-cli-only";
+import { AnyColumn, DBQueryConfig, SQL } from "drizzle-orm";
+
+//#region src/modules/data-tables/server/get-data.server.d.ts
+type GetTableDataOptions<TTable extends PgTable> = DBQueryConfig<"many"> & {
+  table: TTable;
+  where?: SQL;
+  columns?: keyof TTable["_"]["columns"];
+  defaultOrder: (AnyColumn | SQL)[];
+  searchFields: ConvertSearchToQueryParamsFields;
+};
+/**
+ * Get data from the database for the data table
+ */
+declare function getTableData<TTable extends PgTable, TSchema extends TDatabaseSchema>({
+  db,
+  schema
+}: TulipContext<TSchema>, query: TableQuerySchema, options: GetTableDataOptions<TTable>): Promise<{
+  data: TTable["$inferSelect"][];
+  total: number;
+}>;
+//#endregion
+export { GetTableDataOptions, getTableData };

package/dist/src/modules/data-tables/server/get-data.server.mjs

@@ -0,0 +1,47 @@
+import { parseTableQueryPagination } from "../lib/converters/pagination.mjs";
+import { convertSearchToQueryParams } from "../lib/converters/search.mjs";
+import { createTableQuerySortingParser } from "../lib/converters/sorting.mjs";
+import "server-cli-only";
+import { and, getTableColumns, getTableName, isTable } from "drizzle-orm";
+
+//#region src/modules/data-tables/server/get-data.server.ts
+/**
+* Get data from the database for the data table
+*/
+async function getTableData({ db, schema }, query, options) {
+	const { table, where, defaultOrder: defaultSort, searchFields } = options;
+	if (!isTable(table)) throw new Error(`Provided table is not a table: ${table}`);
+	const tableName = Object.entries({ ...schema }).filter(([, t]) => isTable(t)).find(([, t]) => getTableName(t) === getTableName(table))?.[0];
+	if (!tableName) throw new Error(`Table name not found for table: ${tableName}`);
+	const { limit, offset } = parseTableQueryPagination(query);
+	const search = convertSearchToQueryParams(query, searchFields);
+	const orderBy = createTableQuerySortingParser(getTableColumns(table), { fallback: defaultSort }).parse(query);
+	/**
+	* Make a transaction to get the data
+	*/
+	const { data, total } = await db.transaction(async (tx) => {
+		if (!(tableName in tx.query)) throw new Error(`Table not found in query builder: ${tableName}`);
+		const queryBuilderKey = tableName;
+		const queryBuilder = tx.query[queryBuilderKey];
+		if (!queryBuilder) throw new Error(`Query builder not found for table: ${tableName}`);
+		return {
+			data: await queryBuilder.findMany({
+				where: and(where, search),
+				orderBy,
+				limit,
+				offset,
+				with: options.with,
+				columns: options.columns,
+				extras: options.extras
+			}),
+			total: await tx.$count(table, and(where, search)) ?? 0
+		};
+	});
+	return {
+		data,
+		total
+	};
+}
+
+//#endregion
+export { getTableData };

package/dist/src/modules/data-tables/strategies/helpers/sorting.mjs

@@ -0,0 +1,37 @@
+import { z as z$1 } from "zod";
+import { parseAsString, parseAsStringLiteral } from "nuqs";
+
+//#region src/modules/data-tables/strategies/helpers/sorting.ts
+/**
+* Sorting schema
+*/
+const sortingSchema = z$1.object({
+	sort: z$1.string().nullable().optional(),
+	order: z$1.enum(["asc", "desc"]).nullable().optional()
+});
+/**
+* Search params
+*/
+const sortingSearchParams = {
+	sort: parseAsString,
+	order: parseAsStringLiteral(["asc", "desc"])
+};
+function handleSortingChange({ sortingState, setQuery, resetCursor }) {
+	return (updater) => {
+		const newState = typeof updater === "function" ? updater(sortingState) : updater;
+		const { id, desc } = newState[0] ?? {
+			id: null,
+			desc: null
+		};
+		const cursor = resetCursor();
+		setQuery({
+			sort: id?.replaceAll("_", ".") ?? null,
+			order: desc === null ? null : desc ? "desc" : "asc",
+			cursor
+		});
+		return newState;
+	};
+}
+
+//#endregion
+export { handleSortingChange };

package/dist/src/modules/data-tables/strategies/infinite/components.mjs

@@ -0,0 +1,50 @@
+"use client";
+
+import { Skeleton } from "../../../../components/ui/skeleton.mjs";
+import { TableCell, TableRow } from "../../components/table.mjs";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useInView } from "motion/react";
+
+//#region src/modules/data-tables/strategies/infinite/components.tsx
+/**
+* Infinite table bottombar
+*/
+function InfinteTableBottombar({ table }) {
+	const scrollRef = useRef(null);
+	const isInView = useInView(scrollRef);
+	const hasNextPage = table.getCanNextPage();
+	const fetchNextPage = table.nextPage;
+	const { isFetching, isFetchingNextPage } = table.options.meta.strategy.meta;
+	useEffect(() => {
+		if (isInView && hasNextPage && !isFetching && !isFetchingNextPage) fetchNextPage();
+	}, [
+		isInView,
+		fetchNextPage,
+		hasNextPage,
+		isFetching,
+		isFetchingNextPage
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		className: "relative",
+		children: /* @__PURE__ */ jsx("div", {
+			ref: scrollRef,
+			className: "absolute bottom-0 -z-50 min-h-[500px]"
+		})
+	});
+}
+/**
+* Infinite table footer
+*/
+function InfinteTableFooter({ table }) {
+	const { isFetchingNextPage } = table.options.meta.strategy.meta;
+	const pageSize = table.getState().pagination.pageSize;
+	const columnLength = table.getAllFlatColumns().length;
+	return isFetchingNextPage && Array.from({ length: pageSize }).map((_, index) => /* @__PURE__ */ jsx(TableRow, {
+		className: "relative",
+		children: Array.from({ length: columnLength }).map((_, index) => /* @__PURE__ */ jsx(TableCell, { children: /* @__PURE__ */ jsx(Skeleton, { className: "my-2 h-2 w-full rounded-full" }) }, index))
+	}, index));
+}
+
+//#endregion
+export { InfinteTableBottombar, InfinteTableFooter };

package/dist/src/modules/data-tables/strategies/infinite/strategy.d.mts

@@ -0,0 +1,20 @@
+import { TableStrategy } from "../../lib/types.mjs";
+
+//#region src/modules/data-tables/strategies/infinite/strategy.d.ts
+interface UseInfiniteStrategyInput {
+  cursor: number | undefined;
+  total: number | undefined;
+  fetchNextPage: () => void;
+  isFetching: boolean;
+  isFetchingNextPage: boolean;
+}
+type InfiniteStrategyMeta = Pick<UseInfiniteStrategyInput, "isFetching" | "isFetchingNextPage" | "total" | "cursor" | "fetchNextPage">;
+declare function useInfiniteStrategy({
+  cursor,
+  total,
+  fetchNextPage,
+  isFetching,
+  isFetchingNextPage
+}: UseInfiniteStrategyInput): TableStrategy;
+//#endregion
+export { InfiniteStrategyMeta, UseInfiniteStrategyInput, useInfiniteStrategy };

package/dist/src/modules/data-tables/strategies/infinite/strategy.mjs

@@ -0,0 +1,50 @@
+"use client";
+
+import { tableSearchParams } from "../../lib/search-params.mjs";
+import { handleSortingChange } from "../helpers/sorting.mjs";
+import { useQueryStates } from "nuqs";
+
+//#region src/modules/data-tables/strategies/infinite/strategy.ts
+function useInfiniteStrategy({ cursor, total, fetchNextPage, isFetching, isFetchingNextPage }) {
+	const [query, setQuery] = useQueryStates(tableSearchParams);
+	const paginationState = {
+		pageIndex: cursor ?? 0,
+		pageSize: query.limit
+	};
+	const sortingState = query.sort ? [{
+		id: query.sort,
+		desc: query.order === "desc"
+	}] : [];
+	const resetCursor = () => null;
+	return {
+		name: "infinite",
+		rowCount: total,
+		paginationState,
+		manualPagination: true,
+		onPaginationChange: (updater) => {
+			const newState = typeof updater === "function" ? updater(paginationState) : updater;
+			setQuery({ limit: newState.pageSize });
+			fetchNextPage();
+			return newState;
+		},
+		resetCursor,
+		tableSearchParams,
+		sortingState,
+		manualSorting: true,
+		onSortingChange: handleSortingChange({
+			sortingState,
+			setQuery,
+			resetCursor
+		}),
+		meta: {
+			total,
+			cursor,
+			fetchNextPage,
+			isFetching,
+			isFetchingNextPage
+		}
+	};
+}
+
+//#endregion
+export { useInfiniteStrategy };