@reharik/smart-enum 0.0.1

package/dist/database.cjs

@@ -0,0 +1,350 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/database.ts
+var database_exports = {};
+__export(database_exports, {
+  EnumRevivalError: () => EnumRevivalError,
+  enumeration: () => enumeration,
+  isSmartEnum: () => isSmartEnum,
+  isSmartEnumItem: () => isSmartEnumItem,
+  prepareForDatabase: () => prepareForDatabase,
+  revivePayloadFromDatabase: () => revivePayloadFromDatabase,
+  reviveRowFromDatabase: () => reviveRowFromDatabase
+});
+module.exports = __toCommonJS(database_exports);
+
+// src/enumerations.ts
+var import_case_anything = require("case-anything");
+
+// src/extensionMethods.ts
+var addExtensionMethods = (enumItems) => {
+  const findBy = (field, target) => enumItems.find((item) => item[field] === target);
+  const requireBy = (field, target, label) => {
+    const item = findBy(field, target);
+    if (!item) {
+      throw new Error(`No enum ${label} found for '${String(target)}'`);
+    }
+    return item;
+  };
+  return {
+    fromValue: (value) => requireBy("value", value, "value"),
+    tryFromValue: (value) => value ? findBy("value", value) : void 0,
+    fromKey: (key) => requireBy("key", key, "key"),
+    tryFromKey: (key) => key ? findBy("key", key) : void 0,
+    items: () => [...enumItems],
+    values: () => enumItems.map((item) => item.value),
+    keys: () => enumItems.map((item) => item.key)
+  };
+};
+
+// src/types.ts
+var SMART_ENUM_ITEM = Symbol("smart-enum-item");
+var SMART_ENUM_ID = Symbol("smart-enum-id");
+var SMART_ENUM = Symbol("smart-enum");
+
+// src/enumerations.ts
+function normalizeInput(input) {
+  if (Array.isArray(input)) {
+    return Object.fromEntries(
+      input.map((k) => [k, {}])
+    );
+  }
+  return input;
+}
+var finalizeEnumItem = (item, enumType, enumInstanceId) => {
+  Object.defineProperty(item, SMART_ENUM_ITEM, {
+    value: true,
+    enumerable: false
+  });
+  Object.defineProperty(item, SMART_ENUM_ID, {
+    value: enumInstanceId,
+    enumerable: false
+  });
+  Object.defineProperty(item, "__smart_enum_brand", {
+    value: true,
+    enumerable: false
+  });
+  Object.defineProperty(item, "__smart_enum_type", {
+    value: enumType,
+    enumerable: false
+  });
+  Object.defineProperty(item, "toJSON", {
+    value: () => ({ __smart_enum_type: enumType, value: item.value }),
+    enumerable: false
+  });
+  Object.defineProperty(item, "toPostgres", {
+    value: () => item.value,
+    enumerable: false
+  });
+  return item;
+};
+var formatProperties = (k, formatters) => formatters.reduce(
+  (acc, formatter) => {
+    acc[formatter.key] = formatter.format(k);
+    return acc;
+  },
+  {
+    value: (0, import_case_anything.constantCase)(k),
+    display: (0, import_case_anything.capitalCase)(k)
+  }
+);
+function buildEnumFromObject(enumType, input, propertyAutoFormatters) {
+  const formattersWithDefaults = [
+    { key: "value", format: import_case_anything.constantCase },
+    { key: "display", format: import_case_anything.capitalCase },
+    ...propertyAutoFormatters ?? []
+  ];
+  const rawEnumItems = {};
+  const enumInstanceId = Symbol("smart-enum-instance");
+  let index = 0;
+  for (const key in input) {
+    if (Object.prototype.hasOwnProperty.call(input, key)) {
+      const typedKey = key;
+      const value = input[typedKey];
+      const enumItemBase = {
+        index,
+        key: typedKey,
+        ...formatProperties(typedKey, formattersWithDefaults),
+        ...value
+      };
+      const enumItem = finalizeEnumItem(
+        enumItemBase,
+        enumType,
+        enumInstanceId
+      );
+      Object.freeze(enumItem);
+      rawEnumItems[typedKey] = enumItem;
+      index++;
+    }
+  }
+  const extensionMethods = addExtensionMethods(
+    Object.values(rawEnumItems)
+  );
+  const enumObject = {
+    ...rawEnumItems,
+    ...extensionMethods
+  };
+  Object.defineProperty(enumObject, SMART_ENUM, {
+    value: true,
+    enumerable: false
+  });
+  Object.freeze(enumObject);
+  return enumObject;
+}
+function enumeration(enumType, props) {
+  const normalized = normalizeInput(props.input);
+  return buildEnumFromObject(
+    enumType,
+    normalized,
+    props.propertyAutoFormatters
+  );
+}
+
+// src/utilities/typeGuards.ts
+var isSmartEnumItem = (x) => {
+  return !!x && typeof x === "object" && Reflect.get(x, SMART_ENUM_ITEM) === true;
+};
+var isSmartEnum = (x) => {
+  return !!x && typeof x === "object" && Reflect.get(x, SMART_ENUM) === true;
+};
+
+// src/db/prepareForDatabase.ts
+var isPlainObject = (x) => typeof x === "object" && x !== null && Object.getPrototypeOf(x) === Object.prototype;
+var prepareForDatabase = (payload) => {
+  const seen = /* @__PURE__ */ new WeakMap();
+  const walk = (v) => {
+    if (isSmartEnumItem(v)) {
+      return v.value;
+    }
+    if (typeof v === "object" && v !== null && seen.has(v)) {
+      return seen.get(v);
+    }
+    if (Array.isArray(v)) {
+      const arr = [];
+      seen.set(v, arr);
+      for (const item of v) {
+        arr.push(walk(item));
+      }
+      return arr;
+    }
+    if (isPlainObject(v)) {
+      const out = {};
+      seen.set(v, out);
+      for (const [k, val] of Object.entries(v)) {
+        out[k] = walk(val);
+      }
+      return out;
+    }
+    return v;
+  };
+  return walk(payload);
+};
+
+// src/db/enumRevivalError.ts
+var EnumRevivalError = class extends Error {
+  constructor(message, path, value) {
+    super(message);
+    this.path = path;
+    this.value = value;
+    this.name = "EnumRevivalError";
+  }
+};
+
+// src/db/reviveRowFromDatabase.ts
+var reviveRowFromDatabase = (row, options) => {
+  const { fieldEnumMapping, strict = false } = options;
+  const out = { ...row };
+  for (const [field, smartEnum] of Object.entries(fieldEnumMapping)) {
+    if (!Object.hasOwn(out, field)) {
+      continue;
+    }
+    const raw = out[field];
+    if (typeof raw !== "string") {
+      continue;
+    }
+    const revived = smartEnum.tryFromValue(raw);
+    if (revived !== void 0) {
+      out[field] = revived;
+    } else if (strict) {
+      throw new EnumRevivalError(
+        `Cannot revive field ${JSON.stringify(field)}: unknown enum value ${JSON.stringify(raw)}`,
+        field,
+        raw
+      );
+    }
+  }
+  return out;
+};
+
+// src/db/revivePayloadFromDatabase.ts
+var isObjectRecord = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var parsePath = (pathStr) => {
+  const tokens = pathStr.split(".").filter(Boolean);
+  const segs = [];
+  for (const token of tokens) {
+    if (token.endsWith("[]")) {
+      const name = token.slice(0, -2);
+      if (name.length === 0) {
+        throw new Error(
+          `Invalid enum revival path "${pathStr}": empty key before []`
+        );
+      }
+      segs.push({ type: "prop", name }, { type: "arrayEach" });
+    } else {
+      segs.push({ type: "prop", name: token });
+    }
+  }
+  const last = segs.at(-1);
+  if (!last || last.type !== "prop") {
+    throw new Error(
+      `Invalid enum revival path "${pathStr}": must end with a property name (not [])`
+    );
+  }
+  return segs;
+};
+var reviveLeaf = (host, key, smartEnum, strict, pathLabel) => {
+  const raw = host[key];
+  if (typeof raw !== "string") {
+    return;
+  }
+  const revived = smartEnum.tryFromValue(raw);
+  if (revived !== void 0) {
+    host[key] = revived;
+  } else if (strict) {
+    throw new EnumRevivalError(
+      `Cannot revive path "${pathLabel}": unknown enum value ${JSON.stringify(raw)}`,
+      pathLabel,
+      raw
+    );
+  }
+};
+var walkPath = (value, segs, segIndex, smartEnum, strict, pathLabel) => {
+  const seg = segs[segIndex];
+  if (seg === void 0) {
+    return;
+  }
+  const isLast = segIndex === segs.length - 1;
+  if (isLast) {
+    if (seg.type !== "prop") {
+      return;
+    }
+    if (!isObjectRecord(value)) {
+      if (strict) {
+        throw new EnumRevivalError(
+          `Cannot revive path "${pathLabel}": expected object at parent of "${seg.name}"`,
+          pathLabel,
+          value
+        );
+      }
+      return;
+    }
+    reviveLeaf(value, seg.name, smartEnum, strict, pathLabel);
+    return;
+  }
+  if (seg.type === "prop") {
+    if (!isObjectRecord(value)) {
+      if (strict) {
+        throw new EnumRevivalError(
+          `Cannot revive path "${pathLabel}": expected object at "${seg.name}"`,
+          pathLabel,
+          value
+        );
+      }
+      return;
+    }
+    walkPath(value[seg.name], segs, segIndex + 1, smartEnum, strict, pathLabel);
+    return;
+  }
+  if (seg.type === "arrayEach") {
+    if (!Array.isArray(value)) {
+      if (strict) {
+        throw new EnumRevivalError(
+          `Cannot revive path "${pathLabel}": expected array before nested path`,
+          pathLabel,
+          value
+        );
+      }
+      return;
+    }
+    for (const el of value) {
+      walkPath(el, segs, segIndex + 1, smartEnum, strict, pathLabel);
+    }
+  }
+};
+var revivePayloadFromDatabase = (payload, options) => {
+  const { pathEnumMapping, strict = false } = options;
+  const root = structuredClone(payload);
+  for (const [pathStr, smartEnum] of Object.entries(pathEnumMapping)) {
+    const segs = parsePath(pathStr);
+    walkPath(root, segs, 0, smartEnum, strict, pathStr);
+  }
+  return root;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnumRevivalError,
+  enumeration,
+  isSmartEnum,
+  isSmartEnumItem,
+  prepareForDatabase,
+  revivePayloadFromDatabase,
+  reviveRowFromDatabase
+});
+//# sourceMappingURL=database.cjs.map

package/dist/database.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/database.ts","../src/enumerations.ts","../src/extensionMethods.ts","../src/types.ts","../src/utilities/typeGuards.ts","../src/db/prepareForDatabase.ts","../src/db/enumRevivalError.ts","../src/db/reviveRowFromDatabase.ts","../src/db/revivePayloadFromDatabase.ts"],"sourcesContent":["/**\n * Smart Enums — database persistence helpers (`src/db`).\n *\n * Transport wire revival (`initializeSmartEnumMappings`, `reviveAfterTransport`)\n * is exported from `ts-smart-enum/transport` and `ts-smart-enum` root.\n *\n * @example\n * ```typescript\n * import {\n *   enumeration,\n *   prepareForDatabase,\n *   reviveRowFromDatabase,\n * } from 'ts-smart-enum/database';\n * ```\n */\n\nexport { enumeration } from './enumerations.js';\nexport { isSmartEnumItem, isSmartEnum } from './utilities/typeGuards.js';\nexport {\n  prepareForDatabase,\n  reviveRowFromDatabase,\n  revivePayloadFromDatabase,\n  EnumRevivalError,\n} from './db/index.js';\nexport type { Logger } from './utilities/logger.js';\nexport type {\n  Enumeration,\n  AnyEnumLike,\n  DatabaseFormat,\n  SmartApiHelperConfig,\n  LogLevel,\n  SmartEnumMappingsConfig,\n  SmartEnumLike,\n  FieldEnumMapping,\n  ReviveRowOptions,\n  PathEnumMapping,\n  RevivePayloadOptions,\n} from './types.js';\n","import { capitalCase, constantCase } from 'case-anything';\n\nimport { addExtensionMethods } from './extensionMethods.js';\nimport { SMART_ENUM, SMART_ENUM_ID, SMART_ENUM_ITEM } from './types.js';\n\ntype BuiltInOverrideKeys =\n  | 'key'\n  | 'value'\n  | 'display'\n  | 'deprecated'\n  | 'index'\n  | '__smart_enum_brand'\n  | '__smart_enum_type';\n\nexport type StandardEnumItem = {\n  readonly __smart_enum_brand: true;\n  readonly __smart_enum_type: string;\n  readonly key: string;\n  readonly value: string;\n  readonly display: string;\n  readonly index: number;\n  readonly deprecated?: boolean;\n  readonly toPostgres: () => string;\n};\n\nexport type EnumInputItem = Partial<{\n  key: string;\n  value: string;\n  display: string;\n  deprecated: boolean;\n}> &\n  object;\n\nexport type ObjectEnumInput = Record<string, EnumInputItem>;\n\ntype EmptyEnumInputItem = Record<never, never>;\n\ntype Separator = '-' | '_' | ' ' | '.';\n\ntype IsUpperChar<C extends string> =\n  C extends Uppercase<C> ? (C extends Lowercase<C> ? false : true) : false;\n\ntype IsLowerChar<C extends string> =\n  C extends Lowercase<C> ? (C extends Uppercase<C> ? false : true) : false;\n\ntype PushUnderscore<S extends string> = S extends '' | `${string}_`\n  ? S\n  : `${S}_`;\n\ntype TrimUnderscore<S extends string> = S extends `_${infer R}`\n  ? TrimUnderscore<R>\n  : S extends `${infer R}_`\n    ? TrimUnderscore<R>\n    : S;\n\ntype CollapseUnderscores<S extends string> = S extends `${infer A}__${infer B}`\n  ? CollapseUnderscores<`${A}_${B}`>\n  : S;\n\ntype ConstantCaseInternal<\n  S extends string,\n  Prev extends string = '',\n  Out extends string = '',\n> = S extends `${infer C}${infer Rest}`\n  ? C extends Separator\n    ? ConstantCaseInternal<Rest, C, PushUnderscore<Out>>\n    : IsUpperChar<C> extends true\n      ? IsLowerChar<Prev> extends true\n        ? ConstantCaseInternal<Rest, C, `${PushUnderscore<Out>}${Uppercase<C>}`>\n        : ConstantCaseInternal<Rest, C, `${Out}${Uppercase<C>}`>\n      : ConstantCaseInternal<Rest, C, `${Out}${Uppercase<C>}`>\n  : CollapseUnderscores<TrimUnderscore<Out>>;\n\ntype ConstantCase<S extends string> = string extends S\n  ? string\n  : ConstantCaseInternal<S>;\n\ntype ArrayToObjectType<T extends readonly string[]> = {\n  [K in T[number]]: EmptyEnumInputItem & { readonly value?: ConstantCase<K> };\n};\n\ntype NormalizedInputType<TInput> = TInput extends readonly string[]\n  ? ArrayToObjectType<TInput>\n  : TInput extends ObjectEnumInput\n    ? TInput\n    : never;\n\ntype UnionKeys<T> = T extends T ? keyof T : never;\n\ntype MergeUnionToObject<T> = {\n  [K in UnionKeys<T>]: T extends Record<K, infer V> ? V : undefined;\n};\n\ntype ExtraShapeUnion<TObj extends ObjectEnumInput> = {\n  [K in keyof TObj]: Omit<TObj[K], BuiltInOverrideKeys>;\n}[keyof TObj];\n\nexport type InferredExtraFields<TObj extends ObjectEnumInput> =\n  MergeUnionToObject<ExtraShapeUnion<TObj>>;\n\nexport type EnumItemFromNormalizedObject<\n  TObj extends ObjectEnumInput,\n  K extends keyof TObj = keyof TObj,\n> = Omit<StandardEnumItem, 'key' | 'value'> &\n  InferredExtraFields<TObj> & {\n    readonly key: Extract<K, string>;\n    readonly value: TObj[K] extends { value?: infer V }\n      ? Extract<V, string> extends never\n        ? string\n        : Extract<V, string>\n      : string;\n  };\n\nexport type EnumMemberUnionFromNormalizedObject<TObj extends ObjectEnumInput> =\n  {\n    [K in keyof TObj]: EnumItemFromNormalizedObject<TObj, K>;\n  }[keyof TObj];\n\nexport type CoreEnumMethods<TItem extends StandardEnumItem> = {\n  fromValue(value: string): TItem;\n  tryFromValue(value?: string | null): TItem | undefined;\n  fromKey(key: string): TItem;\n  tryFromKey(key?: string | null): TItem | undefined;\n  items(): readonly TItem[];\n  values(): readonly string[];\n  keys(): readonly string[];\n};\n\nexport type EnumFromNormalizedObject<TObj extends ObjectEnumInput> = {\n  [K in keyof TObj]: EnumItemFromNormalizedObject<TObj, K>;\n} & CoreEnumMethods<EnumMemberUnionFromNormalizedObject<TObj>>;\n\nexport type EnumerationProps<TInput> = {\n  input: TInput;\n  propertyAutoFormatters?: PropertyAutoFormatter[];\n};\n\nexport type EnumItem<TEnum> = {\n  [K in keyof TEnum]: TEnum[K] extends { __smart_enum_brand: true }\n    ? TEnum[K]\n    : never;\n}[keyof TEnum];\n\nexport type PropertyAutoFormatter = {\n  key: string;\n  format: (k: string) => string;\n};\n\ntype FinalizedEnumFields = Pick<\n  StandardEnumItem,\n  '__smart_enum_brand' | '__smart_enum_type'\n>;\n\ntype FinalizableEnumItem = {\n  key: string;\n  value: string;\n  display: string;\n  index: number;\n  deprecated?: boolean;\n};\n\nfunction normalizeInput<TInput extends readonly string[] | ObjectEnumInput>(\n  input: TInput,\n): NormalizedInputType<TInput> {\n  if (Array.isArray(input)) {\n    return Object.fromEntries(\n      input.map(k => [k, {}]),\n    ) as NormalizedInputType<TInput>;\n  }\n\n  return input as NormalizedInputType<TInput>;\n}\n\nconst finalizeEnumItem = <T extends { value: string }>(\n  item: T,\n  enumType: string,\n  enumInstanceId: symbol,\n): T & FinalizedEnumFields => {\n  Object.defineProperty(item, SMART_ENUM_ITEM, {\n    value: true,\n    enumerable: false,\n  });\n\n  Object.defineProperty(item, SMART_ENUM_ID, {\n    value: enumInstanceId,\n    enumerable: false,\n  });\n\n  Object.defineProperty(item, '__smart_enum_brand', {\n    value: true,\n    enumerable: false,\n  });\n\n  Object.defineProperty(item, '__smart_enum_type', {\n    value: enumType,\n    enumerable: false,\n  });\n\n  Object.defineProperty(item, 'toJSON', {\n    value: () => ({ __smart_enum_type: enumType, value: item.value }),\n    enumerable: false,\n  });\n\n  Object.defineProperty(item, 'toPostgres', {\n    value: () => item.value,\n    enumerable: false,\n  });\n\n  return item as T & FinalizedEnumFields;\n};\n\nconst formatProperties = (\n  k: string,\n  formatters: PropertyAutoFormatter[],\n): { value: string; display: string } & Record<string, string> =>\n  formatters.reduce(\n    (acc, formatter) => {\n      acc[formatter.key] = formatter.format(k);\n      return acc;\n    },\n    {\n      value: constantCase(k),\n      display: capitalCase(k),\n    } as { value: string; display: string } & Record<string, string>,\n  );\n\nfunction buildEnumFromObject<TObj extends ObjectEnumInput>(\n  enumType: string,\n  input: TObj,\n  propertyAutoFormatters?: PropertyAutoFormatter[],\n): EnumFromNormalizedObject<TObj> {\n  const formattersWithDefaults: PropertyAutoFormatter[] = [\n    { key: 'value', format: constantCase },\n    { key: 'display', format: capitalCase },\n    ...(propertyAutoFormatters ?? []),\n  ];\n\n  type TItem = EnumItemFromNormalizedObject<TObj>;\n\n  const rawEnumItems = {} as {\n    [K in keyof TObj]: EnumItemFromNormalizedObject<TObj, K>;\n  };\n\n  const enumInstanceId = Symbol('smart-enum-instance');\n  let index = 0;\n\n  for (const key in input) {\n    if (Object.prototype.hasOwnProperty.call(input, key)) {\n      const typedKey = key;\n      const value = input[typedKey];\n\n      const enumItemBase = {\n        index,\n        key: typedKey,\n        ...formatProperties(typedKey, formattersWithDefaults),\n        ...value,\n      } as FinalizableEnumItem & TObj[typeof typedKey];\n\n      const enumItem = finalizeEnumItem(\n        enumItemBase,\n        enumType,\n        enumInstanceId,\n      ) as unknown as TItem;\n\n      Object.freeze(enumItem);\n      rawEnumItems[typedKey] = enumItem;\n      index++;\n    }\n  }\n\n  const extensionMethods = addExtensionMethods<TItem>(\n    Object.values(rawEnumItems) as TItem[],\n  );\n\n  const enumObject = {\n    ...rawEnumItems,\n    ...extensionMethods,\n  } as EnumFromNormalizedObject<TObj>;\n\n  Object.defineProperty(enumObject, SMART_ENUM, {\n    value: true,\n    enumerable: false,\n  });\n\n  Object.freeze(enumObject);\n\n  return enumObject;\n}\n\nexport function enumeration<const TArr extends readonly string[]>(\n  enumType: string,\n  props: EnumerationProps<TArr>,\n): EnumFromNormalizedObject<NormalizedInputType<TArr>>;\n\nexport function enumeration<const TObj extends ObjectEnumInput>(\n  enumType: string,\n  props: EnumerationProps<TObj>,\n): EnumFromNormalizedObject<NormalizedInputType<TObj>>;\n\nexport function enumeration(\n  enumType: string,\n  props: EnumerationProps<readonly string[] | ObjectEnumInput>,\n) {\n  const normalized = normalizeInput(props.input);\n  return buildEnumFromObject(\n    enumType,\n    normalized,\n    props.propertyAutoFormatters,\n  );\n}\n","import type { CoreEnumMethods, StandardEnumItem } from './types.js';\nexport const addExtensionMethods = <TItem extends StandardEnumItem>(\n  enumItems: readonly TItem[],\n): CoreEnumMethods<TItem> => {\n  const findBy = <K extends keyof TItem>(field: K, target: TItem[K]) =>\n    enumItems.find(item => item[field] === target);\n\n  const requireBy = <K extends keyof TItem>(\n    field: K,\n    target: TItem[K],\n    label: string,\n  ) => {\n    const item = findBy(field, target);\n    if (!item) {\n      throw new Error(`No enum ${label} found for '${String(target)}'`);\n    }\n    return item;\n  };\n\n  return {\n    fromValue: value => requireBy('value', value as TItem['value'], 'value'),\n    tryFromValue: value =>\n      value ? findBy('value', value as TItem['value']) : undefined,\n\n    fromKey: key => requireBy('key', key as TItem['key'], 'key'),\n    tryFromKey: key => (key ? findBy('key', key as TItem['key']) : undefined),\n\n    items: () => [...enumItems],\n    values: () => enumItems.map(item => item.value),\n    keys: () => enumItems.map(item => item.key),\n  };\n};\n","/**\n * Type guard to check if a value is not null or undefined\n * @param value - The value to check\n * @returns True if the value is defined and not null\n */\nexport const notEmpty = <X>(\n  value: X | null | undefined,\n): value is NonNullable<X> => {\n  // eslint-disable-next-line unicorn/no-null\n  return value != null;\n};\n\n// Public symbols used at runtime for detection/identity (not used in type keys)\nexport const SMART_ENUM_ITEM = Symbol('smart-enum-item');\nexport const SMART_ENUM_ID = Symbol('smart-enum-id');\nexport const SMART_ENUM = Symbol('smart-enum');\n\n/**\n * Options for filtering enum items in various methods\n */\nexport type EnumFilterOptions = {\n  /** Include items with null/undefined values (default: false) */\n  showEmpty?: boolean;\n  /** Include deprecated items (default: false) */\n  showDeprecated?: boolean;\n};\n\n// export type EnumInput = readonly string[] | ObjectEnumInput;\n\n/**\n * Compile-time transformer: replaces Smart Enum items with string values,\n * recursively over arrays and objects. Structural detection checks for\n * presence of `key` and `value`.\n */\nexport type SerializedSmartEnums<T> = T extends { value: string; key: unknown }\n  ? string\n  : T extends ReadonlyArray<infer U>\n    ? ReadonlyArray<SerializedSmartEnums<U>>\n    : T extends Array<infer U>\n      ? SerializedSmartEnums<U>[]\n      : T extends object\n        ? { [K in keyof T]: SerializedSmartEnums<T[K]> }\n        : T;\n\n/**\n * Revived shape: for keys present in mapping M, the string becomes the\n * corresponding enum item type (derived from the provided enum object);\n * other fields recurse.\n */\nexport type EnumItemFromEnum<TEnum> =\n  TEnum extends Record<string, infer V>\n    ? V extends { __smart_enum_brand: true }\n      ? V\n      : never\n    : never;\n\n// Structural constraint for enum objects passed to reviveSmartEnums mapping\nexport type AnyEnumLike = {\n  tryFromValue: (value?: string | null) => unknown;\n  tryFromKey: (key?: string | null) => unknown;\n} & Record<string, unknown>;\n\nexport type SmartEnumLike<T = unknown> = {\n  tryFromValue: (value: string) => T | undefined;\n};\n\nexport type FieldEnumMapping = Record<string, SmartEnumLike>;\n\nexport type ReviveRowOptions = {\n  fieldEnumMapping: FieldEnumMapping;\n  strict?: boolean;\n};\n\nexport type PathEnumMapping = Record<string, SmartEnumLike>;\n\nexport type RevivePayloadOptions = {\n  pathEnumMapping: PathEnumMapping;\n  strict?: boolean;\n};\n\nexport type RevivedSmartEnums<T, M extends Record<string, AnyEnumLike>> =\n  T extends ReadonlyArray<infer U>\n    ? RevivedSmartEnums<U, M>[]\n    : T extends Array<infer U>\n      ? RevivedSmartEnums<U, M>[]\n      : T extends object\n        ? {\n            [K in keyof T]: K extends Extract<keyof M, string>\n              ? Enumeration<M[K]>\n              : RevivedSmartEnums<T[K], M>;\n          }\n        : T;\n\nexport type SmartEnumItemSerialized = {\n  __smart_enum_type: string;\n  value: string;\n};\n\n/** Example shape for transport tests (`reviveAfterTransport` registry). */\nexport type SmartApiHelperConfig = {\n  enumRegistry: Record<string, AnyEnumLike>;\n};\n\n/**\n * Compile-time transformer: replaces Smart Enum items with string values,\n * recursively over arrays and objects. Used for database storage.\n */\nexport type DatabaseFormat<T> = T extends { value: string; key: unknown }\n  ? string\n  : T extends ReadonlyArray<infer U>\n    ? ReadonlyArray<DatabaseFormat<U>>\n    : T extends Array<infer U>\n      ? DatabaseFormat<U>[]\n      : T extends object\n        ? { [K in keyof T]: DatabaseFormat<T[K]> }\n        : T;\n\n/**\n * Log levels for smart enum mappings\n */\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\n/**\n * Configuration for smart enum mappings initialization\n */\nexport type SmartEnumMappingsConfig = {\n  enumRegistry: Record<string, AnyEnumLike>;\n  logLevel?: LogLevel;\n  logger?: import('./utilities/logger.js').Logger;\n};\n\ntype BuiltInOverrideKeys =\n  | 'key'\n  | 'value'\n  | 'display'\n  | 'deprecated'\n  | 'index'\n  | '__smart_enum_brand'\n  | '__smart_enum_type';\n\nexport type StandardEnumItem = {\n  readonly __smart_enum_brand: true;\n  readonly __smart_enum_type: string;\n  readonly key: string;\n  readonly value: string;\n  readonly display: string;\n  readonly index: number;\n  readonly deprecated?: boolean;\n  readonly toPostgres: () => string;\n};\nexport type EnumInputItem = Partial<{\n  key: string;\n  value: string;\n  display: string;\n  deprecated: boolean;\n}> &\n  Record<string, unknown>;\n\nexport type ObjectEnumInput = Record<string, EnumInputItem>;\n\nexport type EmptyEnumInputItem = Record<never, never>;\n\nexport type ArrayToObjectType<T extends readonly string[]> = {\n  [K in T[number]]: EmptyEnumInputItem;\n};\n\nexport type NormalizedInputType<TInput> = TInput extends readonly string[]\n  ? ArrayToObjectType<TInput>\n  : TInput extends ObjectEnumInput\n    ? TInput\n    : never;\n\nexport type EnumItemFromNormalizedObject<\n  TObj extends ObjectEnumInput,\n  K extends keyof TObj = keyof TObj,\n> = Omit<StandardEnumItem, 'key'> &\n  InferredExtraFields<TObj> & {\n    readonly key: Extract<K, string>;\n  };\n\nexport type EnumMemberUnionFromNormalizedObject<TObj extends ObjectEnumInput> =\n  {\n    [K in keyof TObj]: EnumItemFromNormalizedObject<TObj, K>;\n  }[keyof TObj];\n\nexport type EnumFromNormalizedObject<TObj extends ObjectEnumInput> = {\n  [K in keyof TObj]: EnumItemFromNormalizedObject<TObj, K>;\n} & CoreEnumMethods<EnumMemberUnionFromNormalizedObject<TObj>>;\n\nexport type UnionKeys<T> = T extends T ? keyof T : never;\n\n/*\nTo widen the type of the OptionalObject from literals to their actual types,\ne.g.\nshape?: \"round\" | \"square\" | \"long\";\nslices?: true;\nlayers?: 2;\n--turns into:--\nshape: string | undefined;\nslices: boolean| undefined;\nlayers: number| undefined;\n\nwe can use the following code:\ntype Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T;\n\ntype MergeUnionToObject<T> = {\n  [K in UnionKeys<T>]: T extends Record<K, infer V> ? Widen<V> : undefined;\n};\n*/\n\ntype MergeUnionToObject<T> = {\n  [K in UnionKeys<T>]: T extends Record<K, infer V> ? V : undefined;\n};\n\ntype ExtraShapeUnion<TObj extends ObjectEnumInput> = {\n  [K in keyof TObj]: Omit<TObj[K], BuiltInOverrideKeys>;\n}[keyof TObj];\n\nexport type InferredExtraFields<TObj extends ObjectEnumInput> =\n  MergeUnionToObject<ExtraShapeUnion<TObj>>;\n\nexport type PropertyAutoFormatter = {\n  /** The property name to generate */\n  key: string;\n  /** Function to transform the key into the property value */\n  format: (k: string) => string;\n};\n\nexport type CoreEnumMethods<TItem extends StandardEnumItem> = {\n  fromValue(value: string): TItem;\n  tryFromValue(value?: string | null): TItem | undefined;\n  fromKey(key: string): TItem;\n  tryFromKey(key?: string | null): TItem | undefined;\n  items(): readonly TItem[];\n  values(): readonly string[];\n  keys(): readonly string[];\n};\n\nexport type EnumerationProps<TInput> = {\n  input: TInput;\n  propertyAutoFormatters?: PropertyAutoFormatter[];\n};\n\nexport type Enumeration<TEnum> =\n  TEnum extends Record<string, infer V>\n    ? V extends { __smart_enum_brand: true }\n      ? V\n      : never\n    : never;\n\nexport type FinalizedEnumFields = Pick<\n  StandardEnumItem,\n  '__smart_enum_brand' | '__smart_enum_type'\n>;\nexport type FinalizableEnumItem = {\n  key: string;\n  value: string;\n  display: string;\n  index: number;\n  deprecated?: boolean;\n};\n","import {\n  SMART_ENUM_ITEM,\n  SMART_ENUM,\n  SmartEnumItemSerialized,\n} from '../types.js';\n\n/**\n * Runtime type guard to detect Smart Enum items created by this library.\n * Returns true if the value has the SMART_ENUM_ITEM symbol.\n *\n * @example\n * ```typescript\n * import { Status } from './status';\n * const item = Status.active;\n * isSmartEnumItem(item); // true\n * isSmartEnumItem({ key: 'active', value: 'ACTIVE' }); // false (plain object)\n * if (isSmartEnumItem(x)) {\n *   console.log(x.value, x.__smart_enum_type); // narrowed to enum item\n * }\n * ```\n */\nexport const isSmartEnumItem = (\n  x: unknown,\n): x is {\n  key: string;\n  value: string;\n  index?: number;\n  __smart_enum_type?: string;\n} => {\n  return (\n    !!x && typeof x === 'object' && Reflect.get(x, SMART_ENUM_ITEM) === true\n  );\n};\n\n/**\n * Runtime type guard to detect a full Smart Enum object created by this library.\n * Returns true if the object has the SMART_ENUM property.\n *\n * @example\n * ```typescript\n * import { MyEnum } from './blah';\n * isSmartEnum(MyEnum) === true; // true\n * isSmartEnum(MyEnum.one) === false; // false (this is an item, not the enum)\n * ```\n */\nexport const isSmartEnum = (x: unknown): boolean => {\n  return !!x && typeof x === 'object' && Reflect.get(x, SMART_ENUM) === true;\n};\n\n/**\n * Runtime type guard to detect a serialized Smart Enum item created by this library.\n * Returns true if the value has `__smart_enum_type` and `value` (wire/database shape).\n *\n * @example\n * ```typescript\n * const wire = { __smart_enum_type: 'Status', value: 'ACTIVE' };\n * isSerializedSmartEnumItem(wire); // true\n * isSerializedSmartEnumItem(Status.active); // false (live enum item)\n * if (isSerializedSmartEnumItem(x)) {\n *   reviveItem(x.__smart_enum_type, x.value); // narrowed to SmartEnumItemSerialized\n * }\n * ```\n */\nexport const isSerializedSmartEnumItem = (\n  x: unknown,\n): x is SmartEnumItemSerialized => {\n  return (\n    !!x &&\n    typeof x === 'object' &&\n    Reflect.has(x, '__smart_enum_type') &&\n    Reflect.has(x, 'value')\n  );\n};\n","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":[]}

package/dist/database.d.cts

@@ -0,0 +1,20 @@
+import { D as DatabaseFormat, h as ReviveRowOptions, j as RevivePayloadOptions } from './core-DgjOZ8Bg.cjs';
+export { A as AnyEnumLike, E as Enumeration, F as FieldEnumMapping, b as LogLevel, L as Logger, P as PathEnumMapping, S as SmartApiHelperConfig, g as SmartEnumLike, c as SmartEnumMappingsConfig, e as enumeration, a as isSmartEnum, i as isSmartEnumItem } from './core-DgjOZ8Bg.cjs';
+
+/**
+ * Recursively replaces smart enum items with their `.value` strings for persistence.
+ * Inbound revival requires explicit mapping (`reviveRowFromDatabase`, etc.).
+ */
+declare const prepareForDatabase: <T>(payload: T) => DatabaseFormat<T>;
+
+declare const reviveRowFromDatabase: <T extends Record<string, unknown>>(row: T, options: ReviveRowOptions) => T;
+
+declare const revivePayloadFromDatabase: <T>(payload: T, options: RevivePayloadOptions) => T;
+
+declare class EnumRevivalError extends Error {
+    readonly path: string;
+    readonly value: unknown;
+    constructor(message: string, path: string, value: unknown);
+}
+
+export { DatabaseFormat, EnumRevivalError, RevivePayloadOptions, ReviveRowOptions, prepareForDatabase, revivePayloadFromDatabase, reviveRowFromDatabase };

package/dist/database.d.ts

@@ -0,0 +1,20 @@
+import { D as DatabaseFormat, h as ReviveRowOptions, j as RevivePayloadOptions } from './core-DgjOZ8Bg.js';
+export { A as AnyEnumLike, E as Enumeration, F as FieldEnumMapping, b as LogLevel, L as Logger, P as PathEnumMapping, S as SmartApiHelperConfig, g as SmartEnumLike, c as SmartEnumMappingsConfig, e as enumeration, a as isSmartEnum, i as isSmartEnumItem } from './core-DgjOZ8Bg.js';
+
+/**
+ * Recursively replaces smart enum items with their `.value` strings for persistence.
+ * Inbound revival requires explicit mapping (`reviveRowFromDatabase`, etc.).
+ */
+declare const prepareForDatabase: <T>(payload: T) => DatabaseFormat<T>;
+
+declare const reviveRowFromDatabase: <T extends Record<string, unknown>>(row: T, options: ReviveRowOptions) => T;
+
+declare const revivePayloadFromDatabase: <T>(payload: T, options: RevivePayloadOptions) => T;
+
+declare class EnumRevivalError extends Error {
+    readonly path: string;
+    readonly value: unknown;
+    constructor(message: string, path: string, value: unknown);
+}
+
+export { DatabaseFormat, EnumRevivalError, RevivePayloadOptions, ReviveRowOptions, prepareForDatabase, revivePayloadFromDatabase, reviveRowFromDatabase };

package/dist/database.js

@@ -0,0 +1,21 @@
+import {
+  EnumRevivalError,
+  prepareForDatabase,
+  revivePayloadFromDatabase,
+  reviveRowFromDatabase
+} from "./chunk-YGXDKW6W.js";
+import {
+  enumeration,
+  isSmartEnum,
+  isSmartEnumItem
+} from "./chunk-NASPJET6.js";
+export {
+  EnumRevivalError,
+  enumeration,
+  isSmartEnum,
+  isSmartEnumItem,
+  prepareForDatabase,
+  revivePayloadFromDatabase,
+  reviveRowFromDatabase
+};
+//# sourceMappingURL=database.js.map

package/dist/database.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}