@reharik/smart-enum 0.4.0 → 0.4.2

package/README.md

@@ -1,380 +0,0 @@
-# @reharik/smart-enum
-
-Type-safe, feature-rich enumerations for TypeScript. Every enum member is a frozen object with a key, a wire value, a display string, an index, and whatever custom fields you need — plus lookup, iteration, serialization, and database revival built in.
-
-## Why not just use TypeScript enums?
-
-TypeScript's built-in `enum` gives you a name-to-value mapping and nothing else. You can't iterate members, attach metadata, look up by value at runtime, or serialize/revive across a network boundary without writing boilerplate every time.
-
-The common workarounds each solve one piece:
-
-- **Plain objects** (`{ ACTIVE: 'active' }`) — no iteration, no type narrowing, no metadata, annoying text duplication.
-- **String unions** (`type Status = 'active' | 'inactive'`) — compile-time only. No runtime lookup, no `.display`, no `.items()`.
-- **Arrays** (`['active', 'inactive'] as const`) — iterable, but no keyed access or metadata.
-- **Constants** (const ME = "me") — scattered and hard to iterate
-
-Smart Enums give you all of it in one construct:
-
-```typescript
-import { enumeration, type Enumeration } from '@reharik/smart-enum';
-
-const Status = enumeration('Status', {
-  input: ['pending', 'active', 'completed'] as const,
-});
-type Status = Enumeration<typeof Status>;
-
-Status.active;
-// { key: 'active', value: 'ACTIVE', display: 'Active', index: 1 }
-
-Status.fromValue('ACTIVE'); // Status.active
-Status.tryFromValue('NOPE'); // undefined
-Status.items(); // all members as a frozen array
-Status.values(); // ['PENDING', 'ACTIVE', 'COMPLETED']
-Status.keys(); // ['pending', 'active', 'completed']
-```
-
-Type safety works the way you'd expect — a function that takes `Status` won't accept a member from a different enum, even if the shapes look similar.
-
-## Install
-
-```bash
-npm install @reharik/smart-enum
-```
-
-## Creating enums
-
-### From an array
-
-The simplest form. Keys are the array values, wire values are auto-derived as `CONSTANT_CASE`, display strings as `Title Case`.
-
-```typescript
-const Color = enumeration('Color', {
-  input: ['red', 'blue', 'green'] as const,
-});
-type Color = Enumeration<typeof Color>;
-
-Color.red.key; // 'red'
-Color.red.value; // 'RED'
-Color.red.display; // 'Red'
-Color.red.index; // 0
-```
-
-> **`as const` is required** on array inputs. Without it, TypeScript widens the type to `string[]` and you lose literal inference on keys and values.
-
-### From an object
-
-When you need custom values, display strings, or extra fields per member:
-
-```typescript
-const Priority = enumeration('Priority', {
-  input: {
-    low: { display: 'Low Priority' },
-    medium: { display: 'Medium Priority' },
-    high: { value: 'P1', display: 'High Priority' },
-    urgent: { value: 'P0', display: 'Urgent!!!' },
-  } as const,
-});
-type Priority = Enumeration<typeof Priority>;
-
-Priority.high.value; // 'P1' (explicit)
-Priority.low.value; // 'LOW' (auto-derived from key)
-Priority.urgent.display; // 'Urgent!!!'
-```
-
-If you omit `value`, it's derived from the key via `constantCase`. If you omit `display`, it's derived via `capitalCase`. You can override either or both per member.
-
-### Custom fields
-
-Any extra properties you put on a member are preserved with full type inference:
-
-```typescript
-const AppError = enumeration('AppError', {
-  input: {
-    notFound: { source: 'api', httpStatus: 404 },
-    unauthorized: { source: 'auth', httpStatus: 401 },
-    serverError: { source: 'api', httpStatus: 500 },
-  } as const,
-});
-
-AppError.notFound.source; // 'api' (literal type)
-AppError.notFound.httpStatus; // 404 (literal type)
-
-// You can Extract by custom fields:
-type ApiErrors = Extract<Enumeration<typeof AppError>, { source: 'api' }>;
-```
-
-### Custom auto-formatters
-
-Override how `value`, `display`, or any auto-generated property is derived from the key:
-
-```typescript
-const Routes = enumeration('Routes', {
-  input: ['userProfile', 'adminDashboard'] as const,
-  propertyAutoFormatters: [
-    { key: 'value', format: k => `/${k}` },
-    { key: 'slug', format: k => k.replace(/([A-Z])/g, '-$1').toLowerCase() },
-  ],
-});
-
-Routes.userProfile.value; // '/userProfile'
-Routes.userProfile.slug; // 'user-profile'
-```
-
-## Lookup methods
-
-Every enum object has these methods. Return types are fully narrowed to the enum's member union.
-
-| Method                | Description                                           |
-| --------------------- | ----------------------------------------------------- |
-| `fromValue(value)`    | Find by wire value. Throws if not found.              |
-| `tryFromValue(value)` | Find by wire value. Returns `undefined` if not found. |
-| `fromKey(key)`        | Find by key. Throws if not found.                     |
-| `tryFromKey(key)`     | Find by key. Returns `undefined` if not found.        |
-| `items()`             | All members as a frozen array.                        |
-| `values()`            | All wire values as an array.                          |
-| `keys()`              | All keys as an array.                                 |
-
-## Subsetting by a custom field
-
-Filter an enum down to members matching a property value. The result is a new enum-like object with its own `fromValue`, `items`, etc., scoped to the subset:
-
-```typescript
-import { getSubsetByProp, subsetByProp } from '@reharik/smart-enum';
-
-const apiErrors = getSubsetByProp(AppError, 'source', 'api' as const);
-
-apiErrors.notFound; // same object as AppError.notFound
-apiErrors.items(); // only api-source members
-apiErrors.fromValue('500'); // works, scoped to subset
-// apiErrors.unauthorized → not present (source is 'auth')
-
-// Curried form:
-const bySource = subsetByProp('source');
-const authErrors = bySource(AppError, 'auth' as const);
-```
-
-## Tree-shaking
-
-The package has multiple entry points so you only pay for what you import:
-
-```typescript
-// Core only — enumeration + type guards + subset helpers (~149 bytes)
-import { enumeration } from '@reharik/smart-enum/core';
-
-// Core + transport serialization/revival (~406 bytes)
-import { serializeForTransport } from '@reharik/smart-enum/transport';
-
-// Core + database serialization/revival (~379 bytes)
-import { prepareForDatabase } from '@reharik/smart-enum/database';
-
-// Everything (~598 bytes)
-import {
-  enumeration,
-  serializeSmartEnums,
-  prepareForDatabase,
-} from '@reharik/smart-enum';
-```
-
-## Serialization and transport
-
-Smart enum items serialize to self-describing `{ __smart_enum_type, value }` objects for JSON transport. On the receiving end, a registry maps them back to live enum instances.
-
-```typescript
-import { serializeSmartEnums, reviveSmartEnums } from '@reharik/smart-enum';
-
-const dto = { id: '1', status: Status.active, color: Color.red };
-
-// Serialize
-const wire = serializeSmartEnums(dto);
-// { id: '1',
-//   status: { __smart_enum_type: 'Status', value: 'ACTIVE' },
-//   color: { __smart_enum_type: 'Color', value: 'RED' } }
-
-// Revive
-const revived = reviveSmartEnums(wire, { Status, Color });
-// revived.status === Status.active ✓
-```
-
-### Global transport registry
-
-For app-wide setup (e.g. Express middleware), register all enums once at startup:
-
-```typescript
-import {
-  initializeSmartEnumMappings,
-  serializeForTransport,
-  reviveAfterTransport,
-} from '@reharik/smart-enum/transport';
-
-// At startup
-initializeSmartEnumMappings({
-  enumRegistry: { Status, Priority, Color },
-});
-
-// In a handler
-const wire = serializeForTransport(responseData);
-const revived = reviveAfterTransport(requestBody);
-```
-
-## Database utilities
-
-**Outbound:** `prepareForDatabase` recursively replaces enum items with their `.value` strings. Each item also has a `.toPostgres()` method for PostgreSQL drivers that honor it.
-
-**Inbound:** Database columns are plain strings — they don't carry type information. Revival requires you to declare which columns map to which enums.
-
-```typescript
-import {
-  prepareForDatabase,
-  reviveRowFromDatabase,
-  revivePayloadFromDatabase,
-} from '@reharik/smart-enum/database';
-
-// Write
-const dbRow = prepareForDatabase({ name: 'Alice', status: Status.active });
-// { name: 'Alice', status: 'ACTIVE' }
-
-// Read — flat row
-const revived = reviveRowFromDatabase(row, {
-  fieldEnumMapping: { status: Status, priority: Priority },
-  strict: true, // throw on unknown values instead of keeping raw string
-});
-
-// Read — nested payload (e.g. JSONB column)
-const doc = revivePayloadFromDatabase(payload, {
-  pathEnumMapping: {
-    'user.status': Status,
-    'items[].kind': ItemKind,
-  },
-});
-```
-
-`strict: true` throws `EnumRevivalError` when a mapped string doesn't match any member. Without it, unrecognized values are left as-is.
-
-## Type guards
-
-```typescript
-import { isSmartEnumItem, isSmartEnum } from '@reharik/smart-enum';
-
-isSmartEnumItem(Status.active); // true
-isSmartEnumItem({ key: 'x' }); // false (plain object)
-
-isSmartEnum(Status); // true  (the enum object)
-isSmartEnum(Status.active); // false (a member, not the enum)
-```
-
-## GraphQL integration
-
-### Server-side: resolvers returning smart-enum instances
-
-Out of the box, if a GraphQL resolver returns a smart-enum item, the default `serialize` on `GraphQLEnumType` doesn't know how to extract the string value — it just passes the object through, which breaks the response.
-
-`patchSchemaEnumSerializers` walks your executable schema at startup and patches every `GraphQLEnumType.serialize` to call `.value` on smart-enum instances. After that, resolvers can return smart-enum items directly:
-
-```typescript
-import { patchSchemaEnumSerializers } from '@reharik/smart-enum';
-import { makeExecutableSchema } from '@graphql-tools/schema';
-
-const schema = makeExecutableSchema({ typeDefs, resolvers });
-
-// Call once at startup, after schema construction
-patchSchemaEnumSerializers(schema);
-
-// Now resolvers can return smart-enum items directly:
-const resolvers = {
-  Query: {
-    order: () => ({
-      id: '1',
-      status: PaymentStatus.paid, // no .value needed
-      type: OrderType.online,
-    }),
-  },
-};
-```
-
-The patched `serialize` does `val?.value ?? val` — smart-enum items return their `.value` string, and raw strings pass through unchanged. This means you can adopt it incrementally without breaking existing resolvers that already return strings.
-
-### Client-side: Apollo cache rehydration
-
-The [`@reharik/graphql-codegen-smart-enum`](https://www.npmjs.com/package/@reharik/graphql-codegen-smart-enum) package includes a second codegen plugin that generates Apollo `typePolicies` with `read` functions for every enum field. Spread the output into your `InMemoryCache` and components receive smart-enum instances from queries instead of raw strings:
-
-```typescript
-import { InMemoryCache } from '@apollo/client';
-import { smartEnumTypePolicies } from './generated/graphql-smart-enum-type-policies';
-
-const cache = new InMemoryCache({
-  typePolicies: {
-    ...smartEnumTypePolicies,
-  },
-});
-
-// In a component:
-const { data } = useQuery(GET_ORDER);
-data.order.status.display; // 'Paid' — not just 'PAID'
-```
-
-See the [`type-policies` plugin README](https://www.npmjs.com/package/@reharik/graphql-codegen-smart-enum) for setup details.
-
-## React
-
-```tsx
-function StatusPicker() {
-  const [selected, setSelected] = useState(Status.pending);
-
-  return (
-    <select
-      value={selected.value}
-      onChange={e => setSelected(Status.fromValue(e.target.value))}
-    >
-      {Status.items().map(item => (
-        <option key={item.value} value={item.value}>
-          {item.display}
-        </option>
-      ))}
-    </select>
-  );
-}
-```
-
-## The `enumType` string
-
-The first argument to `enumeration()` is a string name used for serialization identity (`__smart_enum_type`) and `toJSON()`. It must be unique across your app and consistent between serialization and revival.
-
-For hand-authored enums, keep it matching the variable name by convention:
-
-```typescript
-const Status = enumeration('Status', { input: ... });
-//    ^^^^^^                 ^^^^^^  ← keep these in sync
-```
-
-If you use the [`@reharik/graphql-codegen-smart-enum`](https://www.npmjs.com/package/@reharik/graphql-codegen-smart-enum) codegen plugin, this is handled automatically — the GraphQL enum type name becomes the `enumType` string.
-
-## Logging
-
-Transport initialization supports pluggable logging:
-
-```typescript
-initializeSmartEnumMappings({
-  enumRegistry: { Status, Priority },
-  logLevel: 'debug', // 'debug' | 'info' | 'warn' | 'error'
-  logger: {
-    debug: (msg, ...args) => myLogger.debug(msg, ...args),
-    info: (msg, ...args) => myLogger.info(msg, ...args),
-    warn: (msg, ...args) => myLogger.warn(msg, ...args),
-    error: (msg, ...args) => myLogger.error(msg, ...args),
-  },
-});
-```
-
-Default is `console` at `'error'` level.
-
-## Related packages
-
-| Package                                                                                                                  | Purpose                                                         |
-| ------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------- |
-| [`@reharik/smart-enum-knex`](https://www.npmjs.com/package/@reharik/smart-enum-knex)                                     | Knex query-level enum revival via `postProcessResponse`         |
-| [`@reharik/graphql-codegen-smart-enum`](https://www.npmjs.com/package/@reharik/graphql-codegen-smart-enum)               | Generate smart-enum definitions from GraphQL schema enums       |
-| [`@reharik/graphql-codegen-smart-enum/type-policies`](https://www.npmjs.com/package/@reharik/graphql-codegen-smart-enum) | Generate Apollo `typePolicies` for client-side enum rehydration |
-
-## License
-
-MIT

package/dist/chunk-6PARBLRO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/db/prepareForDatabase.ts","../src/db/enumRevivalError.ts","../src/db/reviveRowFromDatabase.ts","../src/db/revivePayloadFromDatabase.ts"],"sourcesContent":["import { isSmartEnumItem } from '../utilities/typeGuards.js';\nimport type { DatabaseFormat } from '../types.js';\n\ntype PlainObject = Record<string, unknown>;\n\nconst isPlainObject = (x: unknown): x is PlainObject =>\n  typeof x === 'object' &&\n  x !== null &&\n  Object.getPrototypeOf(x) === Object.prototype;\n\n/**\n * Recursively replaces smart enum items with their `.value` strings for persistence.\n * Inbound revival requires explicit mapping (`reviveRowFromDatabase`, etc.).\n */\nexport const prepareForDatabase = <T>(payload: T): DatabaseFormat<T> => {\n  const seen = new WeakMap<object, unknown>();\n\n  const walk = (v: unknown): unknown => {\n    if (isSmartEnumItem(v)) {\n      return v.value;\n    }\n\n    if (typeof v === 'object' && v !== null && seen.has(v)) {\n      return seen.get(v);\n    }\n\n    if (Array.isArray(v)) {\n      const arr: unknown[] = [];\n      seen.set(v, arr);\n      for (const item of v) {\n        arr.push(walk(item));\n      }\n      return arr;\n    }\n    if (isPlainObject(v)) {\n      const out: PlainObject = {};\n      seen.set(v, out);\n      for (const [k, val] of Object.entries(v)) {\n        out[k] = walk(val);\n      }\n      return out;\n    }\n    return v;\n  };\n\n  return walk(payload) as DatabaseFormat<T>;\n};\n","export class EnumRevivalError extends Error {\n  public constructor(\n    message: string,\n    public readonly path: string,\n    public readonly value: unknown,\n  ) {\n    super(message);\n    this.name = 'EnumRevivalError';\n  }\n}\n","import type { ReviveRowOptions } from '../types.js';\n\nimport { EnumRevivalError } from './enumRevivalError.js';\n\nexport const reviveRowFromDatabase = <T extends Record<string, unknown>>(\n  row: T,\n  options: ReviveRowOptions,\n): T => {\n  const { fieldEnumMapping, strict = false } = options;\n  const out = { ...row } as Record<string, unknown>;\n\n  for (const [field, smartEnum] of Object.entries(fieldEnumMapping)) {\n    if (!Object.hasOwn(out, field)) {\n      continue;\n    }\n    const raw = out[field];\n    if (typeof raw !== 'string') {\n      continue;\n    }\n    const revived = smartEnum.tryFromValue(raw);\n    if (revived !== undefined) {\n      out[field] = revived as unknown;\n    } else if (strict) {\n      throw new EnumRevivalError(\n        `Cannot revive field ${JSON.stringify(field)}: unknown enum value ${JSON.stringify(raw)}`,\n        field,\n        raw,\n      );\n    }\n  }\n\n  return out as T;\n};\n","import type { RevivePayloadOptions, SmartEnumLike } from '../types.js';\n\nimport { EnumRevivalError } from './enumRevivalError.js';\n\ntype PlainObject = Record<string, unknown>;\n\n/** Plain data objects (including `structuredClone` output where prototype may not be Object.prototype). */\nconst isObjectRecord = (x: unknown): x is PlainObject =>\n  typeof x === 'object' && x !== null && !Array.isArray(x);\n\ntype PathSeg = { type: 'prop'; name: string } | { type: 'arrayEach' };\n\nconst parsePath = (pathStr: string): PathSeg[] => {\n  const tokens = pathStr.split('.').filter(Boolean);\n  const segs: PathSeg[] = [];\n\n  for (const token of tokens) {\n    if (token.endsWith('[]')) {\n      const name = token.slice(0, -2);\n      if (name.length === 0) {\n        throw new Error(\n          `Invalid enum revival path \"${pathStr}\": empty key before []`,\n        );\n      }\n      segs.push({ type: 'prop', name }, { type: 'arrayEach' });\n    } else {\n      segs.push({ type: 'prop', name: token });\n    }\n  }\n\n  const last = segs.at(-1);\n  if (!last || last.type !== 'prop') {\n    throw new Error(\n      `Invalid enum revival path \"${pathStr}\": must end with a property name (not [])`,\n    );\n  }\n\n  return segs;\n};\n\nconst reviveLeaf = (\n  host: PlainObject,\n  key: string,\n  smartEnum: SmartEnumLike,\n  strict: boolean,\n  pathLabel: string,\n): void => {\n  const raw = host[key];\n  if (typeof raw !== 'string') {\n    return;\n  }\n  const revived = smartEnum.tryFromValue(raw);\n  if (revived !== undefined) {\n    host[key] = revived as unknown;\n  } else if (strict) {\n    throw new EnumRevivalError(\n      `Cannot revive path \"${pathLabel}\": unknown enum value ${JSON.stringify(raw)}`,\n      pathLabel,\n      raw,\n    );\n  }\n};\n\nconst walkPath = (\n  value: unknown,\n  segs: PathSeg[],\n  segIndex: number,\n  smartEnum: SmartEnumLike,\n  strict: boolean,\n  pathLabel: string,\n): void => {\n  const seg = segs[segIndex];\n  if (seg === undefined) {\n    return;\n  }\n\n  const isLast = segIndex === segs.length - 1;\n\n  if (isLast) {\n    if (seg.type !== 'prop') {\n      return;\n    }\n    if (!isObjectRecord(value)) {\n      if (strict) {\n        throw new EnumRevivalError(\n          `Cannot revive path \"${pathLabel}\": expected object at parent of \"${seg.name}\"`,\n          pathLabel,\n          value,\n        );\n      }\n      return;\n    }\n    reviveLeaf(value, seg.name, smartEnum, strict, pathLabel);\n    return;\n  }\n\n  if (seg.type === 'prop') {\n    if (!isObjectRecord(value)) {\n      if (strict) {\n        throw new EnumRevivalError(\n          `Cannot revive path \"${pathLabel}\": expected object at \"${seg.name}\"`,\n          pathLabel,\n          value,\n        );\n      }\n      return;\n    }\n    walkPath(value[seg.name], segs, segIndex + 1, smartEnum, strict, pathLabel);\n    return;\n  }\n\n  if (seg.type === 'arrayEach') {\n    if (!Array.isArray(value)) {\n      if (strict) {\n        throw new EnumRevivalError(\n          `Cannot revive path \"${pathLabel}\": expected array before nested path`,\n          pathLabel,\n          value,\n        );\n      }\n      return;\n    }\n    for (const el of value) {\n      walkPath(el, segs, segIndex + 1, smartEnum, strict, pathLabel);\n    }\n  }\n};\n\nexport const revivePayloadFromDatabase = <T>(\n  payload: T,\n  options: RevivePayloadOptions,\n): T => {\n  const { pathEnumMapping, strict = false } = options;\n  const root = structuredClone(payload);\n\n  for (const [pathStr, smartEnum] of Object.entries(pathEnumMapping)) {\n    const segs = parsePath(pathStr);\n    walkPath(root as unknown, segs, 0, smartEnum, strict, pathStr);\n  }\n\n  return root;\n};\n"],"mappings":"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","names":[]}