@simplix-react/mock 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,157 @@
+import { PGlite } from '@electric-sql/pglite';
+import * as msw from 'msw';
+import { EntityDefinition, OperationDefinition, ApiContractConfig } from '@simplix-react/contract';
+import { z } from 'zod';
+
+/**
+ * Initialize a PGlite instance with IndexedDB persistence.
+ */
+declare function initPGlite(dataDir: string): Promise<PGlite>;
+/**
+ * Get the current PGlite instance.
+ * Throws if not initialized.
+ */
+declare function getPGliteInstance(): PGlite;
+/**
+ * Reset the PGlite instance (for testing).
+ */
+declare function resetPGliteInstance(): void;
+
+type RequestHandler = unknown;
+interface MockServerConfig {
+    /**
+     * IndexedDB data directory for PGlite persistence
+     */
+    dataDir?: string;
+    /**
+     * Migration functions to run in order
+     */
+    migrations: Array<(db: PGlite) => Promise<void>>;
+    /**
+     * Seed functions to run in order (after migrations)
+     */
+    seed: Array<(db: PGlite) => Promise<void>>;
+    /**
+     * MSW request handlers
+     */
+    handlers: RequestHandler[];
+}
+/**
+ * Set up the mock server with PGlite + MSW.
+ *
+ * 1. Initializes PGlite at the given dataDir
+ * 2. Runs all migrations sequentially
+ * 3. Runs all seed functions sequentially
+ * 4. Starts the MSW service worker
+ */
+declare function setupMockWorker(config: MockServerConfig): Promise<void>;
+
+type AnyEntityDef = EntityDefinition<z.ZodTypeAny, z.ZodTypeAny, z.ZodTypeAny>;
+type AnyOperationDef = OperationDefinition<z.ZodTypeAny, z.ZodTypeAny>;
+/**
+ * Extended entity definition with mock-specific config.
+ * Users pass this as part of the contract config.
+ */
+interface MockEntityConfig {
+    tableName?: string;
+}
+/**
+ * Derive MSW request handlers from an API contract config.
+ *
+ * Generates standard CRUD handlers for each entity:
+ * - GET list (by parent if defined)
+ * - GET by id
+ * - POST create
+ * - PATCH update
+ * - DELETE
+ *
+ * For entities with mock.tableName defined, auto-generates SQL queries.
+ */
+declare function deriveMockHandlers<TEntities extends Record<string, AnyEntityDef>, TOperations extends Record<string, AnyOperationDef>>(config: ApiContractConfig<TEntities, TOperations>, mockConfig?: Record<string, MockEntityConfig>): msw.HttpHandler[];
+
+/**
+ * Unified result type for all mock repository operations.
+ */
+interface MockResult<T> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Create a successful result.
+ */
+declare function mockSuccess<T>(data: T): MockResult<T>;
+/**
+ * Create a failure result.
+ */
+declare function mockFailure(error: {
+    code: string;
+    message: string;
+}): MockResult<never>;
+
+/**
+ * Database row type
+ */
+type DbRow = Record<string, unknown>;
+/**
+ * Convert snake_case string to camelCase
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Convert camelCase string to snake_case
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Map a database row (snake_case) to a camelCase object.
+ * Automatically converts columns ending in `_at` to Date objects.
+ */
+declare function mapRow<T>(row: DbRow): T;
+/**
+ * Map an array of database rows to camelCase objects.
+ */
+declare function mapRows<T>(rows: DbRow[]): T[];
+
+interface SetClauseResult {
+    clause: string;
+    values: unknown[];
+    nextIndex: number;
+}
+/**
+ * Build a dynamic SQL SET clause from a partial object.
+ * Converts camelCase keys to snake_case columns.
+ * Skips undefined values.
+ * Automatically appends `updated_at = NOW()`.
+ */
+declare function buildSetClause<T extends object>(input: T, startIndex?: number): SetClauseResult;
+
+interface MockError {
+    status: number;
+    code: string;
+    message: string;
+}
+/**
+ * Map PostgreSQL errors to HTTP-friendly MockError.
+ */
+declare function mapPgError(err: unknown): MockError;
+
+/**
+ * Check if a table exists in the database.
+ */
+declare function tableExists(db: PGlite, tableName: string): Promise<boolean>;
+/**
+ * Check if a column exists in a table.
+ */
+declare function columnExists(db: PGlite, tableName: string, columnName: string): Promise<boolean>;
+/**
+ * Execute multiple SQL statements separated by semicolons.
+ */
+declare function executeSql(db: PGlite, sql: string): Promise<void>;
+/**
+ * Add a column to a table if it doesn't exist.
+ */
+declare function addColumnIfNotExists(db: PGlite, tableName: string, columnName: string, columnDef: string): Promise<void>;
+
+export { type DbRow, type MockError, type MockResult, type MockServerConfig, type SetClauseResult, addColumnIfNotExists, buildSetClause, columnExists, deriveMockHandlers, executeSql, getPGliteInstance, initPGlite, mapPgError, mapRow, mapRows, mockFailure, mockSuccess, resetPGliteInstance, setupMockWorker, tableExists, toCamelCase, toSnakeCase };

package/dist/index.js

@@ -0,0 +1,362 @@
+import { http, HttpResponse } from 'msw';
+
+// src/pglite.ts
+var instance = null;
+async function initPGlite(dataDir) {
+  if (instance) return instance;
+  const { PGlite: PGliteClass } = await import('@electric-sql/pglite');
+  instance = new PGliteClass(dataDir);
+  return instance;
+}
+function getPGliteInstance() {
+  if (!instance) {
+    throw new Error(
+      "PGlite not initialized. Call initPGlite() first."
+    );
+  }
+  return instance;
+}
+function resetPGliteInstance() {
+  instance = null;
+}
+
+// src/msw.ts
+async function setupMockWorker(config) {
+  const {
+    dataDir = "idb://simplix-mock",
+    migrations,
+    seed,
+    handlers
+  } = config;
+  const db = await initPGlite(dataDir);
+  for (const migration of migrations) {
+    await migration(db);
+  }
+  for (const seedFn of seed) {
+    await seedFn(db);
+  }
+  const { setupWorker } = await import('msw/browser');
+  const worker = setupWorker(...handlers);
+  await worker.start({
+    onUnhandledRequest: "bypass",
+    quiet: true
+  });
+}
+
+// src/sql/row-mapping.ts
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function mapRow(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = toCamelCase(key);
+    if ((key.endsWith("_at") || key === "installed_at" || key === "last_seen_at") && value !== null && value !== void 0) {
+      result[camelKey] = new Date(value);
+    } else {
+      result[camelKey] = value;
+    }
+  }
+  return result;
+}
+function mapRows(rows) {
+  return rows.map((row) => mapRow(row));
+}
+
+// src/sql/query-building.ts
+function buildSetClause(input, startIndex = 1) {
+  const parts = [];
+  const values = [];
+  let index = startIndex;
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0) continue;
+    const column = toSnakeCase(key);
+    if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+      parts.push(`${column} = $${index}::jsonb`);
+      values.push(JSON.stringify(value));
+    } else {
+      parts.push(`${column} = $${index}`);
+      values.push(value);
+    }
+    index++;
+  }
+  parts.push("updated_at = NOW()");
+  return {
+    clause: parts.join(", "),
+    values,
+    nextIndex: index
+  };
+}
+
+// src/sql/error-mapping.ts
+function mapPgError(err) {
+  if (err instanceof Error) {
+    const message = err.message;
+    if (message.includes("unique") || message.includes("duplicate")) {
+      return {
+        status: 409,
+        code: "unique_violation",
+        message: "A record with this value already exists"
+      };
+    }
+    if (message.includes("foreign key") || message.includes("violates foreign key")) {
+      return {
+        status: 422,
+        code: "foreign_key_violation",
+        message: "Referenced record does not exist"
+      };
+    }
+    if (message.includes("not-null") || message.includes("null value")) {
+      return {
+        status: 422,
+        code: "not_null_violation",
+        message: "Required field is missing"
+      };
+    }
+    if (message.includes("not found") || message.includes("no rows")) {
+      return {
+        status: 404,
+        code: "not_found",
+        message: "Record not found"
+      };
+    }
+  }
+  return {
+    status: 500,
+    code: "query_error",
+    message: err instanceof Error ? err.message : "Unknown database error"
+  };
+}
+
+// src/mock-result.ts
+function mockSuccess(data) {
+  return { success: true, data };
+}
+function mockFailure(error) {
+  return { success: false, error };
+}
+
+// src/derive-mock-handlers.ts
+function deriveMockHandlers(config, mockConfig) {
+  const handlers = [];
+  const { basePath, entities } = config;
+  for (const [name, entity] of Object.entries(entities)) {
+    const tableName = mockConfig?.[name]?.tableName ?? toSnakeCase(name) + "s";
+    if (entity.parent) {
+      const listPath = `${basePath}${entity.parent.path}/:${entity.parent.param}${entity.path}`;
+      handlers.push(
+        http.get(listPath, async ({ params }) => {
+          const parentId = params[entity.parent.param];
+          const parentColumn = toSnakeCase(entity.parent.param);
+          return toResponse(
+            await queryList(tableName, parentColumn, parentId)
+          );
+        })
+      );
+    } else {
+      handlers.push(
+        http.get(`${basePath}${entity.path}`, async () => {
+          return toResponse(await queryAll(tableName));
+        })
+      );
+    }
+    handlers.push(
+      http.get(`${basePath}${entity.path}/:id`, async ({ params }) => {
+        const id = params.id;
+        return toResponse(await queryById(tableName, id));
+      })
+    );
+    if (entity.parent) {
+      const createPath = `${basePath}${entity.parent.path}/:${entity.parent.param}${entity.path}`;
+      handlers.push(
+        http.post(createPath, async ({ request, params }) => {
+          const dto = await request.json();
+          const parentId = params[entity.parent.param];
+          dto[entity.parent.param] = parentId;
+          return toResponse(await insertRow(tableName, dto), 201);
+        })
+      );
+    } else {
+      handlers.push(
+        http.post(`${basePath}${entity.path}`, async ({ request }) => {
+          const dto = await request.json();
+          return toResponse(await insertRow(tableName, dto), 201);
+        })
+      );
+    }
+    handlers.push(
+      http.patch(`${basePath}${entity.path}/:id`, async ({ request, params }) => {
+        const id = params.id;
+        const dto = await request.json();
+        return toResponse(await updateRow(tableName, id, dto));
+      })
+    );
+    handlers.push(
+      http.delete(`${basePath}${entity.path}/:id`, async ({ params }) => {
+        const id = params.id;
+        return toResponse(await deleteRow(tableName, id));
+      })
+    );
+  }
+  return handlers;
+}
+async function queryAll(tableName) {
+  try {
+    const db = getPGliteInstance();
+    const result = await db.query(`SELECT * FROM ${tableName} ORDER BY created_at DESC`);
+    return mockSuccess(mapRows(result.rows));
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+async function queryList(tableName, parentColumn, parentId) {
+  try {
+    const db = getPGliteInstance();
+    const result = await db.query(
+      `SELECT * FROM ${tableName} WHERE ${parentColumn} = $1 ORDER BY created_at DESC`,
+      [parentId]
+    );
+    return mockSuccess(mapRows(result.rows));
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+async function queryById(tableName, id) {
+  try {
+    const db = getPGliteInstance();
+    const result = await db.query(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+    if (result.rows.length === 0) {
+      return mockFailure({ code: "not_found", message: `${tableName} not found` });
+    }
+    return mockSuccess(mapRow(result.rows[0]));
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+async function insertRow(tableName, dto) {
+  try {
+    const db = getPGliteInstance();
+    const columns = [];
+    const placeholders = [];
+    const values = [];
+    let index = 1;
+    if (!dto.id) {
+      columns.push("id");
+      placeholders.push(`$${index}`);
+      values.push(crypto.randomUUID());
+      index++;
+    }
+    for (const [key, value] of Object.entries(dto)) {
+      if (value === void 0) continue;
+      const column = toSnakeCase(key);
+      columns.push(column);
+      if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+        placeholders.push(`$${index}::jsonb`);
+        values.push(JSON.stringify(value));
+      } else {
+        placeholders.push(`$${index}`);
+        values.push(value);
+      }
+      index++;
+    }
+    const sql = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING *`;
+    const result = await db.query(sql, values);
+    return mockSuccess(mapRow(result.rows[0]));
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+async function updateRow(tableName, id, dto) {
+  try {
+    const db = getPGliteInstance();
+    const { clause, values, nextIndex } = buildSetClause(dto);
+    if (values.length === 0) {
+      const result2 = await db.query(
+        `UPDATE ${tableName} SET updated_at = NOW() WHERE id = $1 RETURNING *`,
+        [id]
+      );
+      if (result2.rows.length === 0) {
+        return mockFailure({ code: "not_found", message: `${tableName} not found` });
+      }
+      return mockSuccess(mapRow(result2.rows[0]));
+    }
+    const sql = `UPDATE ${tableName} SET ${clause} WHERE id = $${nextIndex} RETURNING *`;
+    const result = await db.query(sql, [...values, id]);
+    if (result.rows.length === 0) {
+      return mockFailure({ code: "not_found", message: `${tableName} not found` });
+    }
+    return mockSuccess(mapRow(result.rows[0]));
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+async function deleteRow(tableName, id) {
+  try {
+    const db = getPGliteInstance();
+    const result = await db.query(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    if (result.affectedRows === 0) {
+      return mockFailure({ code: "not_found", message: `${tableName} not found` });
+    }
+    return mockSuccess(void 0);
+  } catch (err) {
+    const mapped = mapPgError(err);
+    return mockFailure({ code: mapped.code, message: mapped.message });
+  }
+}
+function toResponse(result, successStatus = 200) {
+  if (result.success) {
+    if (successStatus === 204) {
+      return new HttpResponse(null, { status: 204 });
+    }
+    return HttpResponse.json({ data: result.data }, { status: successStatus });
+  }
+  const status = result.error?.code === "not_found" ? 404 : result.error?.code === "unique_violation" ? 409 : result.error?.code === "foreign_key_violation" ? 422 : 500;
+  return HttpResponse.json(
+    { code: result.error?.code, message: result.error?.message },
+    { status }
+  );
+}
+
+// src/sql/migration-helpers.ts
+async function tableExists(db, tableName) {
+  const result = await db.query(
+    `SELECT EXISTS (
+      SELECT FROM information_schema.tables
+      WHERE table_name = $1
+    ) as exists`,
+    [tableName]
+  );
+  return result.rows[0]?.exists ?? false;
+}
+async function columnExists(db, tableName, columnName) {
+  const result = await db.query(
+    `SELECT EXISTS (
+      SELECT FROM information_schema.columns
+      WHERE table_name = $1 AND column_name = $2
+    ) as exists`,
+    [tableName, columnName]
+  );
+  return result.rows[0]?.exists ?? false;
+}
+async function executeSql(db, sql) {
+  const statements = sql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    await db.query(stmt);
+  }
+}
+async function addColumnIfNotExists(db, tableName, columnName, columnDef) {
+  const exists = await columnExists(db, tableName, columnName);
+  if (!exists) {
+    await db.query(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnDef}`);
+  }
+}
+
+export { addColumnIfNotExists, buildSetClause, columnExists, deriveMockHandlers, executeSql, getPGliteInstance, initPGlite, mapPgError, mapRow, mapRows, mockFailure, mockSuccess, resetPGliteInstance, setupMockWorker, tableExists, toCamelCase, toSnakeCase };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@simplix-react/mock",
+  "version": "0.0.1",
+  "description": "Auto-generated MSW handlers and PGlite repositories from @simplix-react/contract",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist .turbo"
+  },
+  "peerDependencies": {
+    "@simplix-react/contract": "workspace:*",
+    "@electric-sql/pglite": ">=0.2.0",
+    "msw": ">=2.0.0",
+    "zod": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@electric-sql/pglite": { "optional": true },
+    "msw": { "optional": true }
+  },
+  "devDependencies": {
+    "@simplix-react/config-typescript": "workspace:*",
+    "@simplix-react/contract": "workspace:*",
+    "@electric-sql/pglite": "^0.3.14",
+    "eslint": "^9.39.2",
+    "msw": "^2.7.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0",
+    "zod": "^4.0.0"
+  }
+}