@porulle/core 0.64.0 → 0.65.0

package/src/auth/access.ts

@@ -1,187 +0,0 @@
-import type { Actor } from "./types.js";
-
-/**
- * A WhereClause is a plain object representing database filter conditions.
- * The shape mirrors what services and repositories can accept to narrow queries.
- *
- * Example: { customerId: "abc-123" } narrows results to that customer's records.
- * Composite: { or: [{ customerId: "x" }, { organizationId: "y" }] }
- */
-export type WhereClause = Record<string, unknown>;
-
-/**
- * AccessResult: the return value of an access function.
- *
- * - `true`: full access, no filter needed
- * - `false`: no access at all
- * - `WhereClause`: partial access — the caller should apply this as a query filter
- */
-export type AccessResult = boolean | WhereClause;
-
-/**
- * AccessContext carries everything an access function needs to make a decision.
- *
- * - `actor`: the authenticated user/api-key/null (anonymous)
- * - `data`: the document being accessed (for document-level checks)
- * - `id`: the document ID (when data isn't loaded yet)
- */
-export interface AccessContext<TData = unknown> {
-  actor: Actor | null;
-  data?: TData;
-  id?: string;
-  req?: Request;
-}
-
-/**
- * An AccessFn evaluates access for a given context.
- * Returns boolean (full/no access) or WhereClause (filtered access).
- */
-export type AccessFn<TData = unknown> = (
-  ctx: AccessContext<TData>,
-) => AccessResult | Promise<AccessResult>;
-
-/**
- * Combines multiple WhereClause objects with a logical operator.
- * If there's only one clause, returns it directly (no unnecessary nesting).
- */
-function combineWhere(
-  queries: WhereClause[],
-  operator: "and" | "or",
-): WhereClause {
-  if (queries.length === 1) return queries[0]!;
-  return { [operator]: queries };
-}
-
-/**
- * Composes access functions with OR semantics.
- *
- * - If ANY function returns `true`, grants full access immediately (short-circuit).
- * - If one or more return WhereClause, combines them with OR.
- * - If ALL return `false`, denies access.
- *
- * Example:
- * ```typescript
- * const orderReadAccess = accessOR(isAdmin, isDocumentOwner("customerId"))
- * // Admins see all orders; customers see only their own
- * ```
- */
-export const accessOR = <TData = unknown>(
-  ...fns: Array<AccessFn<TData>>
-): AccessFn<TData> => {
-  return async (ctx) => {
-    const queries: WhereClause[] = [];
-    for (const fn of fns) {
-      const result = await fn(ctx);
-      if (result === true) return true;
-      if (result && typeof result === "object") queries.push(result);
-    }
-    if (queries.length > 0) return combineWhere(queries, "or");
-    return false;
-  };
-};
-
-/**
- * Composes access functions with AND semantics.
- *
- * - If ANY function returns `false`, denies access immediately (short-circuit).
- * - If one or more return WhereClause, combines them with AND.
- * - If ALL return `true`, grants full access.
- *
- * Example:
- * ```typescript
- * const restrictedAccess = accessAND(isAuthenticated, isDocumentOwner("customerId"))
- * // Must be logged in AND own the document
- * ```
- */
-export const accessAND = <TData = unknown>(
-  ...fns: Array<AccessFn<TData>>
-): AccessFn<TData> => {
-  return async (ctx) => {
-    const queries: WhereClause[] = [];
-    for (const fn of fns) {
-      const result = await fn(ctx);
-      if (result === false) return false;
-      if (result !== true && result && typeof result === "object") {
-        queries.push(result);
-      }
-    }
-    if (queries.length > 0) return combineWhere(queries, "and");
-    return true;
-  };
-};
-
-/**
- * Switches between two access functions based on a condition.
- *
- * Example:
- * ```typescript
- * const accessByRole = conditional(
- *   ({ actor }) => actor?.role === "vendor",
- *   isDocumentOwner("vendorId"),
- *   isAdmin,
- * )
- * ```
- */
-export const conditional = <TData = unknown>(
-  condition: ((ctx: AccessContext<TData>) => boolean) | boolean,
-  accessFn: AccessFn<TData>,
-  fallback: AccessFn<TData> = () => false,
-): AccessFn<TData> => {
-  return async (ctx) => {
-    const applies =
-      typeof condition === "function" ? condition(ctx) : condition;
-    return applies ? accessFn(ctx) : fallback(ctx);
-  };
-};
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Built-in access functions
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * Grants access if the actor has admin or owner role (wildcard permissions).
- */
-export const isAdmin: AccessFn = ({ actor }) => {
-  if (!actor) return false;
-  return actor.permissions.includes("*:*");
-};
-
-/**
- * Grants access if the actor is authenticated (any role).
- */
-export const isAuthenticated: AccessFn = ({ actor }) => {
-  return actor != null;
-};
-
-/**
- * Returns a WhereClause that filters to documents owned by the actor.
- * The ownerField is the column name that holds the owner's user ID.
- *
- * For document-level checks (when data is provided), returns true/false.
- * For list-level checks (when data is not provided), returns a WhereClause.
- */
-export const isDocumentOwner = (
-  ownerField = "customerId",
-): AccessFn => {
-  return ({ actor, data }) => {
-    if (!actor) return false;
-
-    // Document-level check: compare directly
-    if (data) {
-      return (data as Record<string, unknown>)[ownerField] === actor.userId;
-    }
-
-    // List-level check: return a filter clause
-    return { [ownerField]: actor.userId };
-  };
-};
-
-/**
- * Grants access to everyone, including anonymous users.
- */
-export const publicAccess: AccessFn = () => true;
-
-/**
- * Denies access to everyone.
- */
-export const denyAll: AccessFn = () => false;

package/src/generated/plugin-capabilities.d.ts

@@ -1,21 +0,0 @@
-/* eslint-disable */
-// AUTO-GENERATED by scripts/generate-plugin-types.mjs
-
-export interface PluginCapabilityRegistryShape {
-  "appointments": Record<string, unknown>;
-  "channel-connector": Record<string, unknown>;
-  "gift-cards": Record<string, unknown>;
-  "layaway": Record<string, unknown>;
-  "loyalty": Record<string, unknown>;
-  "marketplace": Record<string, unknown>;
-  "notifications": Record<string, unknown>;
-  "pos": Record<string, unknown>;
-  "pos-restaurant": Record<string, unknown>;
-  "procurement": Record<string, unknown>;
-  "production": Record<string, unknown>;
-  "reviews": Record<string, unknown>;
-  "scheduled-orders": Record<string, unknown>;
-  "uom": Record<string, unknown>;
-  "warehouse": Record<string, unknown>;
-  "wishlist": Record<string, unknown>;
-}

package/src/generated/plugin-manifest.ts

@@ -1,24 +0,0 @@
-/* eslint-disable */
-// AUTO-GENERATED by scripts/generate-plugin-types.mjs
-// DO NOT EDIT MANUALLY.
-
-export const resolvedPluginManifest = [
-  { id: "appointments", directory: "plugin-appointments" },
-  { id: "channel-connector", directory: "plugin-channel-connector" },
-  { id: "gift-cards", directory: "plugin-gift-cards" },
-  { id: "layaway", directory: "plugin-layaway" },
-  { id: "loyalty", directory: "plugin-loyalty" },
-  { id: "marketplace", directory: "plugin-marketplace" },
-  { id: "notifications", directory: "plugin-notifications" },
-  { id: "pos", directory: "plugin-pos" },
-  { id: "pos-restaurant", directory: "plugin-pos-restaurant" },
-  { id: "procurement", directory: "plugin-procurement" },
-  { id: "production", directory: "plugin-production" },
-  { id: "reviews", directory: "plugin-reviews" },
-  { id: "scheduled-orders", directory: "plugin-scheduled-orders" },
-  { id: "uom", directory: "plugin-uom" },
-  { id: "warehouse", directory: "plugin-warehouse" },
-  { id: "wishlist", directory: "plugin-wishlist" },
-] as const;
-
-export type ResolvedPluginId = (typeof resolvedPluginManifest)[number]["id"];

package/src/generated/plugin-repositories.d.ts

@@ -1,21 +0,0 @@
-/* eslint-disable */
-// AUTO-GENERATED by scripts/generate-plugin-types.mjs
-
-export interface PluginRepositoryRegistryShape {
-  "appointments": Record<string, unknown>;
-  "channel-connector": Record<string, unknown>;
-  "gift-cards": Record<string, unknown>;
-  "layaway": Record<string, unknown>;
-  "loyalty": Record<string, unknown>;
-  "marketplace": Record<string, unknown>;
-  "notifications": Record<string, unknown>;
-  "pos": Record<string, unknown>;
-  "pos-restaurant": Record<string, unknown>;
-  "procurement": Record<string, unknown>;
-  "production": Record<string, unknown>;
-  "reviews": Record<string, unknown>;
-  "scheduled-orders": Record<string, unknown>;
-  "uom": Record<string, unknown>;
-  "warehouse": Record<string, unknown>;
-  "wishlist": Record<string, unknown>;
-}

package/src/kernel/factory/repository-factory.ts

@@ -1,244 +0,0 @@
-import {
-  eq,
-  and,
-  isNull,
-  sql,
-  getTableColumns,
-  type SQL,
-  type Column,
-  type InferSelectModel,
-  type InferInsertModel,
-} from "drizzle-orm";
-import type { PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
-import { PgTable } from "drizzle-orm/pg-core";
-import type { TxContext } from "../database/tx-context.js";
-import type { DrizzleDatabase, DbOrTx } from "../database/drizzle-db.js";
-import { CommerceNotFoundError } from "../errors.js";
-
-/**
- * Filter type — partial record of column values to match with eq().
- * Only keys that exist on TRow and have non-undefined values are used.
- */
-export type Filters<TRow> = Partial<TRow>;
-
-/**
- * Options for findMany / findAndCount queries.
- */
-export interface FindOptions {
-  limit?: number;
-  offset?: number;
-  orderBy?: Array<{ column: string; direction: "asc" | "desc" }>;
-  withDeleted?: boolean;
-}
-
-/**
- * Standard CRUD operations derived from a Drizzle pgTable schema.
- * All methods support optional TxContext for transaction participation.
- */
-export interface BaseRepository<TRow, TInsert> {
-  findById(id: string, ctx?: TxContext): Promise<TRow | undefined>;
-  findMany(
-    filters?: Filters<TRow>,
-    options?: FindOptions,
-    ctx?: TxContext,
-  ): Promise<TRow[]>;
-  findAndCount(
-    filters?: Filters<TRow>,
-    options?: FindOptions,
-    ctx?: TxContext,
-  ): Promise<{ rows: TRow[]; total: number }>;
-  create(data: TInsert, ctx?: TxContext): Promise<TRow>;
-  createMany(data: TInsert[], ctx?: TxContext): Promise<TRow[]>;
-  update(id: string, data: Partial<TInsert>, ctx?: TxContext): Promise<TRow>;
-  delete(id: string, ctx?: TxContext): Promise<void>;
-}
-
-/**
- * Extended repository for tables with a `deleted_at` column.
- * Adds softDelete and restore operations.
- */
-export interface SoftDeletableRepository<TRow, TInsert>
-  extends BaseRepository<TRow, TInsert> {
-  softDelete(id: string, ctx?: TxContext): Promise<void>;
-  restore(id: string, ctx?: TxContext): Promise<TRow>;
-}
-
-/**
- * Type-level check: does the table config have a `deletedAt` or `deleted_at` column?
- */
-type HasDeletedAt<T extends PgTableWithColumns<TableConfig>> =
-  "deletedAt" extends keyof T ? true : "deleted_at" extends keyof T ? true : false;
-
-/**
- * Conditional repository type: if the table has a deleted_at column,
- * return SoftDeletableRepository; otherwise BaseRepository.
- */
-export type RepositoryFor<T extends PgTableWithColumns<TableConfig>> =
-  HasDeletedAt<T> extends true
-    ? SoftDeletableRepository<InferSelectModel<T>, InferInsertModel<T>>
-    : BaseRepository<InferSelectModel<T>, InferInsertModel<T>>;
-
-/**
- * Creates a typed repository with standard CRUD operations from a Drizzle table schema.
- *
- * Usage:
- * ```typescript
- * const repo = createRepository(schema.promotions, db)
- * const row = await repo.findById("abc-123")
- * const rows = await repo.findMany({ status: "active" }, { limit: 10 })
- * ```
- *
- * Tables with a `deletedAt` column automatically get `softDelete()` and `restore()`.
- * Domain-specific queries should remain in dedicated repository classes that
- * delegate standard CRUD to the factory-created instance.
- */
-export function createRepository<T extends PgTableWithColumns<TableConfig>>(
-  table: T,
-  db: DrizzleDatabase,
-): RepositoryFor<T> {
-  // Use getTableColumns for type-safe column access
-  const columns = getTableColumns(table) as Record<string, Column>;
-
-  // Runtime check for soft-delete column
-  const hasSoftDelete = "deletedAt" in columns || "deleted_at" in columns;
-  const deletedAtColumn: Column | null =
-    columns["deletedAt"] ?? columns["deleted_at"] ?? null;
-  const idColumn = columns["id"]!;
-
-  // Drizzle's generic types require PgTable at the boundary.
-  // We cast once here rather than at every call site.
-  const pgTable = table as PgTable;
-
-  function getDb(ctx?: TxContext): DbOrTx {
-    return (ctx?.tx as DbOrTx | undefined) ?? db;
-  }
-
-  function buildWhereConditions(
-    filters?: Filters<InferSelectModel<T>>,
-    includeDeleted = false,
-  ): SQL[] {
-    const conditions: SQL[] = [];
-
-    // Automatically exclude soft-deleted rows unless explicitly requested
-    if (hasSoftDelete && !includeDeleted && deletedAtColumn) {
-      conditions.push(isNull(deletedAtColumn));
-    }
-
-    if (filters) {
-      for (const [key, value] of Object.entries(filters)) {
-        const col = columns[key];
-        if (value !== undefined && col) {
-          conditions.push(eq(col, value));
-        }
-      }
-    }
-
-    return conditions;
-  }
-
-  const repo: BaseRepository<InferSelectModel<T>, InferInsertModel<T>> = {
-    async findById(id, ctx) {
-      const conditions = buildWhereConditions(undefined, false);
-      conditions.push(eq(idColumn, id));
-      const rows = await getDb(ctx)
-        .select()
-        .from(pgTable)
-        .where(and(...conditions));
-      return rows[0] as InferSelectModel<T> | undefined;
-    },
-
-    async findMany(filters, options = {}, ctx) {
-      const conditions = buildWhereConditions(filters, options.withDeleted);
-      let query = getDb(ctx).select().from(pgTable).$dynamic();
-      if (conditions.length > 0) {
-        query = query.where(and(...conditions));
-      }
-      if (options.limit !== undefined) {
-        query = query.limit(options.limit);
-      }
-      if (options.offset !== undefined) {
-        query = query.offset(options.offset);
-      }
-      // Drizzle's $dynamic() erases the row type when using PgTable.
-      // Use .then() to narrow the resolved array type with a single cast.
-      return query.then((rows) => rows as InferSelectModel<T>[]);
-    },
-
-    async findAndCount(filters, options = {}, ctx) {
-      const rows = await repo.findMany(filters, options, ctx);
-      const conditions = buildWhereConditions(filters, options.withDeleted);
-      let countQuery = getDb(ctx)
-        .select({ count: sql<number>`count(*)::int` })
-        .from(pgTable)
-        .$dynamic();
-      if (conditions.length > 0) {
-        countQuery = countQuery.where(and(...conditions));
-      }
-      const countResult = await countQuery;
-      return { rows, total: countResult[0]?.count ?? 0 };
-    },
-
-    async create(data, ctx) {
-      const rows = await getDb(ctx)
-        .insert(pgTable)
-        .values(data as Record<string, unknown>)
-        .returning();
-      return rows[0] as InferSelectModel<T>;
-    },
-
-    async createMany(data, ctx) {
-      if (data.length === 0) return [];
-      const rows = await getDb(ctx)
-        .insert(pgTable)
-        .values(data as Record<string, unknown>[])
-        .returning();
-      return rows as InferSelectModel<T>[];
-    },
-
-    async update(id, data, ctx) {
-      const rows = await getDb(ctx)
-        .update(pgTable)
-        .set(data as Record<string, unknown>)
-        .where(eq(idColumn, id))
-        .returning();
-      if (!rows[0]) {
-        throw new CommerceNotFoundError(`Record ${id} not found.`);
-      }
-      return rows[0] as InferSelectModel<T>;
-    },
-
-    async delete(id, ctx) {
-      await getDb(ctx).delete(pgTable).where(eq(idColumn, id));
-    },
-  };
-
-  if (hasSoftDelete && deletedAtColumn) {
-    const softRepo = repo as SoftDeletableRepository<
-      InferSelectModel<T>,
-      InferInsertModel<T>
-    >;
-
-    softRepo.softDelete = async (id, ctx) => {
-      await getDb(ctx)
-        .update(pgTable)
-        .set({ deletedAt: new Date() } as Record<string, unknown>)
-        .where(eq(idColumn, id));
-    };
-
-    softRepo.restore = async (id, ctx) => {
-      const rows = await getDb(ctx)
-        .update(pgTable)
-        .set({ deletedAt: null } as Record<string, unknown>)
-        .where(eq(idColumn, id))
-        .returning();
-      if (!rows[0]) {
-        throw new CommerceNotFoundError(`Record ${id} not found.`);
-      }
-      return rows[0] as InferSelectModel<T>;
-    };
-
-    return softRepo as RepositoryFor<T>;
-  }
-
-  return repo as RepositoryFor<T>;
-}

package/src/kernel/http-error.ts

@@ -1,44 +0,0 @@
-/**
- * Converts a PluginResultErr into a structured HTTP error response.
- *
- * Replaces the `throw new Error(result.error)` pattern in plugin routes
- * which always produces HTTP 500 with no structured error code.
- *
- * Usage in routes:
- *   const result = await service.doSomething(orgId, input);
- *   if (!result.ok) return toHttpError(result);
- *   return result.value;
- *
- * The function infers HTTP status from the error code or message content:
- *   - "NOT_FOUND" or "not found"        --> 404
- *   - "FORBIDDEN" or "permission"        --> 403
- *   - "CONFLICT" or "already exists"     --> 409
- *   - "VALIDATION" or "cannot/must"      --> 422
- *   - Everything else                    --> 400
- */
-
-import type { PluginResultErr } from "./result.js";
-
-export interface HttpErrorResponse {
-  status: 400 | 403 | 404 | 409 | 422;
-  body: { error: { code: string; message: string } };
-}
-
-export function toHttpError(result: PluginResultErr): HttpErrorResponse {
-  const message = result.error;
-  const code = result.code;
-
-  if (code === "NOT_FOUND" || /not found/i.test(message)) {
-    return { status: 404, body: { error: { code: "NOT_FOUND", message } } };
-  }
-  if (code === "FORBIDDEN" || /permission|forbidden|unauthorized/i.test(message)) {
-    return { status: 403, body: { error: { code: "FORBIDDEN", message } } };
-  }
-  if (code === "CONFLICT" || /already|duplicate|exists|unique/i.test(message)) {
-    return { status: 409, body: { error: { code: "CONFLICT", message } } };
-  }
-  if (code === "VALIDATION" || /invalid|cannot|must|required|exceeded|negative/i.test(message)) {
-    return { status: 422, body: { error: { code: "VALIDATION_FAILED", message } } };
-  }
-  return { status: 400, body: { error: { code: code ?? "BAD_REQUEST", message } } };
-}

package/src/kernel/jobs/builtin-job-tasks.ts

@@ -1,17 +0,0 @@
-import { webhookDeliveryTask } from "../../modules/webhooks/tasks.js";
-import { staleJobReaperTask } from "./reaper.js";
-import type { TaskDefinition } from "./types.js";
-
-export const defaultKernelJobTasks: TaskDefinition<
-  Record<string, unknown>,
-  Record<string, unknown>
->[] = [
-  webhookDeliveryTask as TaskDefinition<
-    Record<string, unknown>,
-    Record<string, unknown>
-  >,
-  staleJobReaperTask as TaskDefinition<
-    Record<string, unknown>,
-    Record<string, unknown>
-  >,
-];

package/src/kernel/module/define.ts

@@ -1,36 +0,0 @@
-import type { DatabaseAdapter } from "../database/adapter.js";
-import type { HookRegistry } from "../hooks/registry.js";
-import type { Logger } from "../hooks/types.js";
-
-export interface ModuleDeps<TDeps extends Record<string, unknown> = Record<string, unknown>> {
-  db: DatabaseAdapter;
-  hooks: HookRegistry;
-  services: TDeps;
-  config: unknown;
-  logger: Logger;
-}
-
-export interface AppModule<
-  TSchema = unknown,
-  TService = unknown,
-  TDeps extends Record<string, unknown> = Record<string, unknown>,
-> {
-  id: string;
-  schema: () => TSchema;
-  dependencies?: ReadonlyArray<keyof TDeps & string>;
-  service: (deps: ModuleDeps<TDeps>) => TService;
-}
-
-export type ServiceMap<TModules extends Record<string, AppModule>> = {
-  [K in keyof TModules]: TModules[K] extends AppModule<infer _TSchema, infer TService, infer _TDeps>
-    ? TService
-    : never;
-};
-
-export function defineModule<
-  TSchema,
-  TService,
-  TDeps extends Record<string, unknown> = Record<string, unknown>,
->(manifest: AppModule<TSchema, TService, TDeps>): AppModule<TSchema, TService, TDeps> {
-  return manifest;
-}

package/src/kernel/module/index.ts

@@ -1,3 +0,0 @@
-export type { AppModule, ModuleDeps, ServiceMap } from "./define.js";
-export { defineModule } from "./define.js";
-export { ModuleCycleError, topoSortModules } from "./topo-sort.js";