@mesob/common 0.0.1

package/.turbo/turbo-check-types.log

@@ -0,0 +1,5 @@
+
+
+> @jiret/common@0.1.0 check-types /Users/misikir/Projects/jiret/jiret-v2/packages/common
+> tsc --noEmit
+

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@mesob/common",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./logger": "./src/utility/logger.ts",
+    "./dayjs": "./src/lib/dayjs/index.ts"
+  },
+  "dependencies": {
+    "dayjs": "^1.11.13",
+    "drizzle-orm": "^0.44.4",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "lint": "biome check --write .",
+    "check-types": "tsc --noEmit"
+  }
+}

package/src/entity/entity-filter-condition.ts

@@ -0,0 +1,79 @@
+import type { SQL, SQLWrapper } from 'drizzle-orm';
+import {
+  eq,
+  gt,
+  gte,
+  ilike,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+} from 'drizzle-orm';
+import type { EntityListRequest } from './entity-list-request';
+
+type FilterOperator =
+  | 'eq'
+  | 'neq'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'like'
+  | 'ilike'
+  | 'is'
+  | 'is_not';
+
+type Column = SQLWrapper | SQL;
+
+const operatorMap: Record<
+  Exclude<FilterOperator, 'is' | 'is_not'>,
+  (col: Column, val: string) => SQL
+> = {
+  eq: (col, val) => eq(col as any, val),
+  neq: (col, val) => ne(col as any, val),
+  gt: (col, val) => gt(col as any, val),
+  gte: (col, val) => gte(col as any, val),
+  lt: (col, val) => lt(col as any, val),
+  lte: (col, val) => lte(col as any, val),
+  like: (col, val) => like(col as any, val),
+  ilike: (col, val) => ilike(col as any, val),
+};
+
+const buildCondition = (
+  column: Column,
+  value: string,
+  operator: FilterOperator = 'eq',
+): SQL | undefined => {
+  if (operator === 'is') {
+    return isNull(column as any);
+  }
+  if (operator === 'is_not') {
+    return not(isNull(column as any));
+  }
+  const fn = operatorMap[operator];
+  return fn ? fn(column, value) : undefined;
+};
+
+export const entityFilterCondition = <T extends Record<string, Column>>(
+  filters: EntityListRequest['f'],
+  columnMap: T,
+): SQL[] => {
+  if (!filters) {
+    return [];
+  }
+
+  const conditions: SQL[] = [];
+  for (const filter of filters) {
+    const col = columnMap[filter.f as keyof T];
+    if (!col) {
+      continue;
+    }
+    const condition = buildCondition(col, filter.v, filter.o ?? 'eq');
+    if (condition) {
+      conditions.push(condition);
+    }
+  }
+  return conditions;
+};

package/src/entity/entity-list-request-schema.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+
+export const entityListRequestSchema = z
+  .object({
+    s: z.string().optional().describe('Search term'),
+    l: z.coerce
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe('Limit (per page)'),
+    f: z
+      .union([
+        z.array(
+          z.object({
+            f: z.string().describe('Field name'),
+            v: z.string().describe('Field value'),
+            o: z
+              .enum([
+                'eq',
+                'neq',
+                'gt',
+                'gte',
+                'lt',
+                'lte',
+                'like',
+                'ilike',
+                'is',
+                'is_not',
+              ])
+              .optional()
+              .default('eq')
+              .describe('Filter operator'),
+          }),
+        ),
+        z.string().transform((str, ctx) => {
+          try {
+            return JSON.parse(str) as Array<{
+              f: string;
+              v: string;
+              o?:
+                | 'eq'
+                | 'neq'
+                | 'gt'
+                | 'gte'
+                | 'lt'
+                | 'lte'
+                | 'like'
+                | 'ilike'
+                | 'is'
+                | 'is_not';
+            }>;
+          } catch {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: 'Invalid JSON string for filter',
+            });
+            return z.NEVER;
+          }
+        }),
+      ])
+      .optional()
+      .describe('Filters'),
+    o: z
+      .union([
+        z.object({
+          f: z.string().describe('Order field'),
+          d: z
+            .enum(['asc', 'desc'])
+            .default('desc')
+            .describe('Order direction'),
+        }),
+        z.string().transform((str, ctx) => {
+          try {
+            const parsed = JSON.parse(str) as { f: string; d?: 'asc' | 'desc' };
+            return {
+              f: parsed.f,
+              d: parsed.d || 'desc',
+            };
+          } catch {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: 'Invalid JSON string for order',
+            });
+            return z.NEVER;
+          }
+        }),
+      ])
+      .optional()
+      .describe('Ordering'),
+    p: z.coerce.number().min(1).optional().describe('Page number'),
+    pp: z.coerce.number().min(1).max(100).optional().describe('Per page'),
+  })
+  .strict();

package/src/entity/entity-list-request.ts

@@ -0,0 +1,27 @@
+export type EntityListRequest = {
+  s?: string; // search
+  l?: number; // local
+  f?: Array<{
+    // filter
+    f: string;
+    v: string;
+    o?:
+      | 'eq'
+      | 'neq'
+      | 'gt'
+      | 'gte'
+      | 'lt'
+      | 'lte'
+      | 'like'
+      | 'ilike'
+      | 'is'
+      | 'is_not';
+  }>;
+  o?: {
+    // order
+    f: string;
+    d: 'asc' | 'desc';
+  };
+  p?: number; // page
+  pp?: number; // per page
+};

package/src/entity/entity-list-response.ts

@@ -0,0 +1,4 @@
+export type EntityListResponse<T> = {
+  data: T[];
+  total: number;
+};

package/src/entity/entity-list.ts

@@ -0,0 +1,201 @@
+import type {
+  Column,
+  ColumnBaseConfig,
+  ColumnDataType,
+  SQLWrapper,
+} from 'drizzle-orm';
+import {
+  eq,
+  gt,
+  gte,
+  ilike,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  or,
+  type SQL,
+} from 'drizzle-orm';
+import type { EntityListRequest } from './entity-list-request';
+
+type FilterOperator =
+  | 'eq'
+  | 'neq'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'like'
+  | 'ilike'
+  | 'is'
+  | 'is_not';
+
+const operatorMap: Partial<
+  Record<
+    FilterOperator,
+    (
+      column:
+        | Column<ColumnBaseConfig<ColumnDataType, string>, object, object>
+        | SQLWrapper,
+      value?: string,
+    ) => SQLWrapper | SQL
+  >
+> = {
+  eq: (col, val) =>
+    eq(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  neq: (col, val) =>
+    ne(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  gt: (col, val) =>
+    gt(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  gte: (col, val) =>
+    gte(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  lt: (col, val) =>
+    lt(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  lte: (col, val) =>
+    lte(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  like: (col, val) =>
+    like(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+  ilike: (col, val) =>
+    ilike(
+      col as Column<ColumnBaseConfig<ColumnDataType, string>, object, object>,
+      val ?? '',
+    ),
+};
+
+type EntityListParams<T> = {
+  search?: SQLWrapper[];
+  filter?: EntityListRequest['f'];
+  booleanFilter?: {
+    column: Column<ColumnBaseConfig<ColumnDataType, string>, object, object>;
+    value: boolean;
+  };
+  orderByConfig?: {
+    column: string | SQLWrapper;
+    direction: 'asc' | 'desc';
+  };
+  p?: number;
+  pp?: number;
+  tenantId?: string;
+  entity: T;
+  skipTenantIdFilter?: boolean;
+};
+
+export const entityList = <T extends Record<string, unknown>>({
+  search = [],
+  filter,
+  booleanFilter,
+  orderByConfig = { column: 'createdAt', direction: 'desc' },
+  p = 1,
+  pp = 10,
+  tenantId,
+  entity,
+  skipTenantIdFilter = false,
+}: EntityListParams<T>) => {
+  const page = Number(p);
+  const pageSize = Number(pp);
+  const conditions: (SQL | SQLWrapper)[] = [];
+
+  if (tenantId && !skipTenantIdFilter && 'tenantId' in entity) {
+    const tenantColumn = (
+      entity as unknown as {
+        tenantId: Column<
+          ColumnBaseConfig<ColumnDataType, string>,
+          object,
+          object
+        >;
+      }
+    ).tenantId;
+    conditions.push(eq(tenantColumn, tenantId));
+  }
+
+  if (search.length > 0) {
+    const searchConditions = search.map((column) => column);
+    const searchCondition = or(...searchConditions);
+    if (searchCondition) {
+      conditions.push(searchCondition);
+    }
+  }
+
+  if (filter) {
+    conditions.push(
+      ...filter.map((column) => {
+        const op = (column.o ?? 'eq') as FilterOperator;
+        const columnObj = (
+          entity as Record<
+            string,
+            Column<ColumnBaseConfig<ColumnDataType, string>, object, object>
+          >
+        )[column.f];
+
+        if (!columnObj) {
+          throw new Error(`Column '${column.f}' not found on entity`);
+        }
+
+        if (op === 'is') {
+          return isNull(columnObj);
+        }
+        if (op === 'is_not') {
+          return not(isNull(columnObj));
+        }
+
+        const operatorFn = operatorMap[op];
+        if (!operatorFn) {
+          throw new Error(`Unsupported operator: ${op}`);
+        }
+
+        return operatorFn(columnObj, column.v);
+      }),
+    );
+  }
+
+  if (booleanFilter) {
+    conditions.push(eq(booleanFilter.column, booleanFilter.value));
+  }
+
+  return {
+    conditions,
+    orderByConfig,
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+  };
+};
+
+export const entityResponse = <T extends { totalCount: number }>(
+  result: T[],
+): { data: Omit<T, 'totalCount'>[]; total: number } => {
+  const total = result.length > 0 ? result[0].totalCount : 0;
+
+  const data = result.map((item) => {
+    // biome-ignore lint/correctness/noUnusedVariables: intentionally destructuring to remove totalCount
+    const { totalCount, ...rest } = item;
+    return rest;
+  }) as Omit<T, 'totalCount'>[];
+
+  return {
+    data,
+    total,
+  };
+};

package/src/entity/entity-pagination.ts

@@ -0,0 +1,14 @@
+/**
+ * Parses rows from a query using COUNT(*) OVER() window function
+ * Returns clean data without totalCount and extracts total
+ */
+export const entityPaginatedRows = <T extends { totalCount: number }>(
+  rows: T[],
+): { data: Omit<T, 'totalCount'>[]; total: number } => {
+  const total = rows[0]?.totalCount ?? 0;
+  const data = rows.map(({ totalCount: _, ...rest }) => rest) as Omit<
+    T,
+    'totalCount'
+  >[];
+  return { data, total };
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+/** biome-ignore-all lint/performance/noBarrelFile: <explanation> */
+
+export { entityFilterCondition } from './entity/entity-filter-condition';
+export { entityList, entityResponse } from './entity/entity-list';
+export type { EntityListRequest } from './entity/entity-list-request';
+export { entityListRequestSchema } from './entity/entity-list-request-schema';
+export type { EntityListResponse } from './entity/entity-list-response';
+export { entityPaginatedRows } from './entity/entity-pagination';
+export { default as dayjs } from './lib/dayjs/index';
+export { EmploymentType, VerificationStatus } from './types';
+export { default as logger } from './utility/logger';

package/src/lib/dayjs/index.ts

@@ -0,0 +1,27 @@
+// biome-ignore lint/style/noExportedImports: this is a library
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import duration from 'dayjs/plugin/duration';
+import isBetween from 'dayjs/plugin/isBetween';
+import isToday from 'dayjs/plugin/isToday';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+import minmax from 'dayjs/plugin/minMax';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import timeZone from 'dayjs/plugin/timezone';
+import toArray from 'dayjs/plugin/toArray';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(customParseFormat);
+dayjs.extend(isBetween);
+dayjs.extend(isToday);
+dayjs.extend(localizedFormat);
+dayjs.extend(relativeTime);
+dayjs.extend(timeZone);
+dayjs.extend(toArray);
+dayjs.extend(utc);
+dayjs.extend(minmax);
+dayjs.extend(duration);
+
+type _Dayjs = dayjs.Dayjs;
+
+export default dayjs;

package/src/types.ts

@@ -0,0 +1,26 @@
+export enum VerificationStatus {
+  PENDING = 'pending',
+  VERIFIED = 'verified',
+  DRAFT = 'draft',
+  PUBLISHED = 'published',
+  ARCHIVED = 'archived',
+  EXPIRED = 'expired',
+  MISMATCH = 'mismatch',
+  NOT_FOUND = 'not_found',
+  CLOSED = 'closed',
+  PAUSED = 'paused',
+  OPEN = 'open',
+  TOO_MANY_ATTEMPTS = 'too_many_attempts',
+  REQUIRES_VERIFICATION = 'requires_verification',
+  UNAUTHORIZED = 'unauthorized',
+  ACCESS_DENIED = 'access_denied',
+  HAS_NO_PASSWORD = 'has_no_password',
+}
+
+export enum EmploymentType {
+  FULL_TIME = 'full_time',
+  PART_TIME = 'part_time',
+  CONTRACT = 'contract',
+  INTERNSHIP = 'internship',
+  TEMPORARY = 'temporary',
+}

package/src/utility/logger.ts

@@ -0,0 +1,56 @@
+/** biome-ignore-all lint/complexity/noBannedTypes: <explanation> */
+/** biome-ignore-all lint/suspicious/noEmptyBlockStatements: <explanation> */
+/** biome-ignore-all lint/suspicious/noConsole: <explanation> */
+
+const getLocalStorage = (): {
+  getItem: (key: string) => string | null;
+} | null => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const win = globalThis as any;
+    return win?.window?.localStorage ?? null;
+  } catch {
+    return null;
+  }
+};
+
+class LoggerService {
+  debugMode = false;
+
+  constructor() {
+    const storage = getLocalStorage();
+    if (storage) {
+      this.debugMode =
+        process.env.NODE_ENV === 'development'
+          ? true
+          : JSON.parse(storage.getItem('jiret:debug') ?? 'false');
+    } else {
+      this.debugMode = true;
+    }
+  }
+
+  public get log(): Function {
+    return this.debugMode ? console.log.bind(console) : (): void => {};
+  }
+  public get debug(): any {
+    return this.debugMode ? console.debug.bind(console) : (): void => {};
+  }
+  public get info(): any {
+    return this.debugMode ? console.info.bind(console) : (): void => {};
+  }
+  public get warn(): any {
+    return this.debugMode ? console.warn.bind(console) : (): void => {};
+  }
+
+  public get error(): Function {
+    return this.debugMode ? console.error.bind(console) : (): void => {};
+  }
+
+  public get table(): Function {
+    return this.debugMode ? console.table.bind(console) : (): void => {};
+  }
+}
+
+const logger = new LoggerService();
+
+export default logger;

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}