promidas 2.0.0

package/dist/schemas/normalized-prototype.js

@@ -0,0 +1,123 @@
+/**
+ * Validation schema for NormalizedPrototype.
+ *
+ * This module provides a Zod schema for validating the structure
+ * of normalized prototype objects.
+ */
+import { z } from 'zod';
+/**
+ * Validation schema for NormalizedPrototype.
+ *
+ * This schema validates the structure of a single prototype object.
+ * Used internally for validating deserialized snapshot data.
+ *
+ * @remarks
+ * This is a comprehensive schema covering all fields of NormalizedPrototype.
+ * Optional fields are marked with .optional() and must be undefined (not null)
+ * due to exactOptionalPropertyTypes: true.
+ */
+export const normalizedPrototypeSchema = z.object({
+    /* ID */
+    id: z.number().int().positive(),
+    /* Editorial information  */
+    createDate: z.string(),
+    updateDate: z.string().optional(),
+    releaseDate: z.string().optional(),
+    createId: z.number().int().optional(),
+    updateId: z.number().int().optional(),
+    /**
+     * Valid release flag code values.
+     *
+     * - 1: '下書き保存' (Draft) - Not accessible via public API
+     * - 2: '一般公開' (Public) - Only this value appears in API responses
+     * - 3: '限定共有' (Limited Sharing) - Not accessible via public API
+     */
+    releaseFlg: z.union([
+        //
+        z.literal(1),
+        z.literal(2),
+        z.literal(3),
+    ]),
+    /* Basic information */
+    /**
+     * Valid status code values.
+     *
+     * - 1: 'アイデア' (Idea)
+     * - 2: '開発中' (In Development)
+     * - 3: '完成' (Completed)
+     * - 4: '供養' (Retired/Memorial)
+     *
+     * All four status values appear in public API responses.
+     */
+    status: z.union([
+        //
+        z.literal(1),
+        z.literal(2),
+        z.literal(3),
+        z.literal(4),
+    ]),
+    prototypeNm: z.string(),
+    summary: z.string(),
+    freeComment: z.string(),
+    systemDescription: z.string(),
+    /** Users and Team */
+    users: z.array(z.string()),
+    teamNm: z.string(),
+    /** Tags, Materials, Events, and Awards */
+    tags: z.array(z.string()),
+    materials: z.array(z.string()),
+    events: z.array(z.string()),
+    awards: z.array(z.string()),
+    /* URLs */
+    // URL of official site (if any)
+    officialLink: z.string().optional(),
+    // URL of YouTube or Vimeo video (if any)
+    videoUrl: z.string().optional(),
+    // URL of eyecatch image
+    mainUrl: z.string(),
+    // URLs of related link
+    relatedLink: z.string().optional(),
+    relatedLink2: z.string().optional(),
+    relatedLink3: z.string().optional(),
+    relatedLink4: z.string().optional(),
+    relatedLink5: z.string().optional(),
+    /* counts */
+    viewCount: z.number().int(),
+    goodCount: z.number().int(),
+    commentCount: z.number().int(),
+    /* Others */
+    uuid: z.string().optional(),
+    nid: z.string().optional(),
+    revision: z.number().int().optional(),
+    /**
+     * Valid license type code values.
+     *
+     * - 0: 'なし' (None) - Not observed in API responses
+     * - 1: '表示(CC:BY)' (Display with CC BY license) - All API responses have this value
+     */
+    licenseType: z
+        .union([
+        //
+        z.literal(0),
+        z.literal(1),
+    ])
+        .optional(),
+    /**
+     * Valid thanks flag code values.
+     *
+     * - 0: (Implicit) Message not yet shown - Rarely or never seen in API responses
+     * - 1: '初回表示済' ("Thank you for posting" message shown) - Most common value
+     * - undefined: Field not present in older prototypes (pre-thanksFlg era, ~3.26% of data)
+     *
+     * Note: Historical data may not include this field. Always handle undefined case.
+     */
+    thanksFlg: z
+        .union([
+        //
+        z.literal(0),
+        z.literal(1),
+    ])
+        .optional(),
+    slideMode: z.number().int().optional(),
+});
+//# sourceMappingURL=normalized-prototype.js.map

package/dist/schemas/normalized-prototype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalized-prototype.js","sourceRoot":"","sources":["../../lib/schemas/normalized-prototype.ts"],"names":[],"mappings":"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"}

package/dist/store/errors/store-error.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Error classes for PrototypeInMemoryStore operations.
+ *
+ * @module
+ */
+/**
+ * Represents the state of stored data when an error occurs.
+ *
+ * - `UNCHANGED`: The store's existing data remains intact and unmodified
+ * - `UNKNOWN`: The data state is unknown or unspecified (for future extensions)
+ */
+export type StoreDataState = 'UNCHANGED' | 'UNKNOWN';
+/**
+ * Base error class for PrototypeInMemoryStore operations.
+ *
+ * All store-specific errors extend this class, allowing callers to catch
+ * all store errors with a single catch block if desired. Each error includes
+ * a `dataState` property indicating whether the store's data was affected.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof StoreError) {
+ *     console.error('Store operation failed:', error.message);
+ *     console.log('Data state:', error.dataState); // 'UNCHANGED' or 'UNKNOWN'
+ *   }
+ * }
+ * ```
+ */
+export declare class StoreError extends Error {
+    /**
+     * Indicates the state of the store's data when this error occurred.
+     */
+    readonly dataState: StoreDataState;
+    /**
+     * Creates a new StoreError.
+     *
+     * @param message - Human-readable error message
+     * @param dataState - State of the store's data (defaults to 'UNKNOWN')
+     * @param options - Error options, including the original error cause for debugging
+     */
+    constructor(message: string, dataState?: StoreDataState, options?: ErrorOptions);
+}
+/**
+ * Thrown when store configuration is invalid.
+ *
+ * This error indicates that the configuration provided to the store
+ * constructor contains invalid values. Common causes include exceeding
+ * maximum allowed limits or providing incompatible settings.
+ *
+ * This error is thrown before the store is created, so no data state applies.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const store = new PrototypeInMemoryStore({
+ *     maxDataSizeBytes: 50 * 1024 * 1024, // 50 MiB exceeds 30 MiB limit
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ConfigurationError) {
+ *     console.error('Invalid configuration:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export declare class ConfigurationError extends StoreError {
+    /**
+     * Creates a new ConfigurationError.
+     *
+     * @param message - Human-readable error message describing the configuration issue
+     */
+    constructor(message: string);
+}
+/**
+ * Thrown when snapshot data size exceeds the configured maximum limit.
+ *
+ * This error indicates that the prototypes being stored exceed the
+ * `maxDataSizeBytes` limit configured for the store. The error includes
+ * both the actual data size and the maximum allowed size for debugging.
+ *
+ * When this error is thrown, the store's data remains UNCHANGED.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof DataSizeExceededError) {
+ *     console.error(
+ *       `Data too large: ${error.dataSizeBytes} bytes ` +
+ *       `(max: ${error.maxDataSizeBytes} bytes)`
+ *     );
+ *     console.log('Previous data intact:', error.dataState === 'UNCHANGED');
+ *   }
+ * }
+ * ```
+ */
+export declare class DataSizeExceededError extends StoreError {
+    /**
+     * Actual size of the data in bytes.
+     */
+    readonly dataSizeBytes: number;
+    /**
+     * Maximum allowed size in bytes.
+     */
+    readonly maxDataSizeBytes: number;
+    /**
+     * Creates a new DataSizeExceededError.
+     *
+     * @param dataState - State of the store's data
+     * @param dataSizeBytes - Actual size of the data in bytes
+     * @param maxDataSizeBytes - Maximum allowed size in bytes
+     */
+    constructor(dataState: StoreDataState, dataSizeBytes: number, maxDataSizeBytes: number);
+}
+/**
+ * Thrown when data size estimation fails.
+ *
+ * This error indicates that the store was unable to calculate the size
+ * of the prototypes being stored, typically due to JSON serialization
+ * failures (e.g., circular references, unsupported types).
+ *
+ * When this error is thrown, the store's data remains UNCHANGED.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof SizeEstimationError) {
+ *     console.error('Cannot estimate data size:', error.cause);
+ *     console.log('Previous data intact:', error.dataState === 'UNCHANGED');
+ *   }
+ * }
+ * ```
+ */
+export declare class SizeEstimationError extends StoreError {
+    /**
+     * Creates a new SizeEstimationError.
+     *
+     * @param dataState - State of the store's data (defaults to 'UNKNOWN')
+     * @param cause - The underlying error that caused the estimation to fail
+     */
+    constructor(dataState?: StoreDataState, cause?: Error);
+}
+//# sourceMappingURL=store-error.d.ts.map

package/dist/store/errors/store-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-error.d.ts","sourceRoot":"","sources":["../../../lib/store/errors/store-error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;OAEG;IACH,SAAgB,SAAS,EAAE,cAAc,CAAC;IAE1C;;;;;;OAMG;gBAED,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,cAA0B,EACrC,OAAO,CAAC,EAAE,YAAY;CAMzB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,kBAAmB,SAAQ,UAAU;IAChD;;;;OAIG;gBACS,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACnD;;OAEG;IACH,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC;;OAEG;IACH,SAAgB,gBAAgB,EAAE,MAAM,CAAC;IAEzC;;;;;;OAMG;gBAED,SAAS,EAAE,cAAc,EACzB,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM;CAU3B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,UAAU;IACjD;;;;;OAKG;gBACS,SAAS,GAAE,cAA0B,EAAE,KAAK,CAAC,EAAE,KAAK;CAIjE"}

package/dist/store/errors/store-error.js

@@ -0,0 +1,156 @@
+/**
+ * Error classes for PrototypeInMemoryStore operations.
+ *
+ * @module
+ */
+/**
+ * Base error class for PrototypeInMemoryStore operations.
+ *
+ * All store-specific errors extend this class, allowing callers to catch
+ * all store errors with a single catch block if desired. Each error includes
+ * a `dataState` property indicating whether the store's data was affected.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof StoreError) {
+ *     console.error('Store operation failed:', error.message);
+ *     console.log('Data state:', error.dataState); // 'UNCHANGED' or 'UNKNOWN'
+ *   }
+ * }
+ * ```
+ */
+export class StoreError extends Error {
+    /**
+     * Indicates the state of the store's data when this error occurred.
+     */
+    dataState;
+    /**
+     * Creates a new StoreError.
+     *
+     * @param message - Human-readable error message
+     * @param dataState - State of the store's data (defaults to 'UNKNOWN')
+     * @param options - Error options, including the original error cause for debugging
+     */
+    constructor(message, dataState = 'UNKNOWN', options) {
+        super(message, options);
+        this.name = 'StoreError';
+        this.dataState = dataState;
+    }
+}
+/**
+ * Thrown when store configuration is invalid.
+ *
+ * This error indicates that the configuration provided to the store
+ * constructor contains invalid values. Common causes include exceeding
+ * maximum allowed limits or providing incompatible settings.
+ *
+ * This error is thrown before the store is created, so no data state applies.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const store = new PrototypeInMemoryStore({
+ *     maxDataSizeBytes: 50 * 1024 * 1024, // 50 MiB exceeds 30 MiB limit
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ConfigurationError) {
+ *     console.error('Invalid configuration:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export class ConfigurationError extends StoreError {
+    /**
+     * Creates a new ConfigurationError.
+     *
+     * @param message - Human-readable error message describing the configuration issue
+     */
+    constructor(message) {
+        super(message, 'UNKNOWN');
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Thrown when snapshot data size exceeds the configured maximum limit.
+ *
+ * This error indicates that the prototypes being stored exceed the
+ * `maxDataSizeBytes` limit configured for the store. The error includes
+ * both the actual data size and the maximum allowed size for debugging.
+ *
+ * When this error is thrown, the store's data remains UNCHANGED.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof DataSizeExceededError) {
+ *     console.error(
+ *       `Data too large: ${error.dataSizeBytes} bytes ` +
+ *       `(max: ${error.maxDataSizeBytes} bytes)`
+ *     );
+ *     console.log('Previous data intact:', error.dataState === 'UNCHANGED');
+ *   }
+ * }
+ * ```
+ */
+export class DataSizeExceededError extends StoreError {
+    /**
+     * Actual size of the data in bytes.
+     */
+    dataSizeBytes;
+    /**
+     * Maximum allowed size in bytes.
+     */
+    maxDataSizeBytes;
+    /**
+     * Creates a new DataSizeExceededError.
+     *
+     * @param dataState - State of the store's data
+     * @param dataSizeBytes - Actual size of the data in bytes
+     * @param maxDataSizeBytes - Maximum allowed size in bytes
+     */
+    constructor(dataState, dataSizeBytes, maxDataSizeBytes) {
+        super(`Snapshot data size (${dataSizeBytes} bytes) exceeds maximum limit (${maxDataSizeBytes} bytes)`, dataState);
+        this.name = 'DataSizeExceededError';
+        this.dataSizeBytes = dataSizeBytes;
+        this.maxDataSizeBytes = maxDataSizeBytes;
+    }
+}
+/**
+ * Thrown when data size estimation fails.
+ *
+ * This error indicates that the store was unable to calculate the size
+ * of the prototypes being stored, typically due to JSON serialization
+ * failures (e.g., circular references, unsupported types).
+ *
+ * When this error is thrown, the store's data remains UNCHANGED.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   store.setAll(prototypes);
+ * } catch (error) {
+ *   if (error instanceof SizeEstimationError) {
+ *     console.error('Cannot estimate data size:', error.cause);
+ *     console.log('Previous data intact:', error.dataState === 'UNCHANGED');
+ *   }
+ * }
+ * ```
+ */
+export class SizeEstimationError extends StoreError {
+    /**
+     * Creates a new SizeEstimationError.
+     *
+     * @param dataState - State of the store's data (defaults to 'UNKNOWN')
+     * @param cause - The underlying error that caused the estimation to fail
+     */
+    constructor(dataState = 'UNKNOWN', cause) {
+        super('Failed to estimate data size for snapshot', dataState, { cause });
+        this.name = 'SizeEstimationError';
+    }
+}
+//# sourceMappingURL=store-error.js.map

package/dist/store/errors/store-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-error.js","sourceRoot":"","sources":["../../../lib/store/errors/store-error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC;;OAEG;IACa,SAAS,CAAiB;IAE1C;;;;;;OAMG;IACH,YACE,OAAe,EACf,YAA4B,SAAS,EACrC,OAAsB;QAEtB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,kBAAmB,SAAQ,UAAU;IAChD;;;;OAIG;IACH,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,qBAAsB,SAAQ,UAAU;IACnD;;OAEG;IACa,aAAa,CAAS;IAEtC;;OAEG;IACa,gBAAgB,CAAS;IAEzC;;;;;;OAMG;IACH,YACE,SAAyB,EACzB,aAAqB,EACrB,gBAAwB;QAExB,KAAK,CACH,uBAAuB,aAAa,kCAAkC,gBAAgB,SAAS,EAC/F,SAAS,CACV,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;IAC3C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,mBAAoB,SAAQ,UAAU;IACjD;;;;;OAKG;IACH,YAAY,YAA4B,SAAS,EAAE,KAAa;QAC9D,KAAK,CAAC,2CAA2C,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF"}

package/dist/store/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * In-Memory Prototype Storage Module.
+ *
+ * This module provides a complete storage layer for managing in-memory snapshots
+ * of prototype data, including TTL-based expiration, size limits, and efficient
+ * ID-based lookups. It can be used as a standalone module for custom caching
+ * solutions or integrated with the repository layer.
+ *
+ * ## Core Components
+ *
+ * - {@link PrototypeInMemoryStore} — Main store class with snapshot management, TTL expiration, and ID-based lookups.
+ * - {@link PrototypeInMemoryStoreConfig} — Configuration options including TTL and max data size.
+ * - {@link PrototypeInMemoryStats} — Statistics and metadata about the current store state.
+ *
+ * ### Storage Operations & Result Types
+ *
+ * - {@link SetResult} — Discriminated union result type for `setAll` operations.
+ * - {@link StoreErrorCode} — Error codes for precise error classification.
+ * - {@link StoreFailureKind} — Failure kinds: `'storage_limit'`, `'serialization'`, or `'unknown'`.
+ *
+ * ### Error Handling
+ *
+ * The store throws exceptions by default, but also provides Result types for
+ * consumers who prefer explicit error handling:
+ *
+ * - {@link StoreError} — Base error class for all store errors.
+ * - {@link ConfigurationError} — Configuration validation errors.
+ * - {@link DataSizeExceededError} — Data size limit exceeded.
+ * - {@link SizeEstimationError} — Size estimation failures.
+ * - {@link StoreDataState} — Data state after operation: `'UNCHANGED'`, `'CLEARED'`, or `'UNKNOWN'`.
+ *
+ * ### Dependencies
+ *
+ * - {@link NormalizedPrototype} — The data type stored in the store.
+ * - {@link Logger} — Logger interface for custom logging implementations.
+ * - {@link LogLevel} — Log level type for controlling logger verbosity.
+ *
+ * ## Standalone Usage
+ *
+ * This module is designed to work independently, allowing you to:
+ * - Create custom in-memory caching solutions
+ * - Build data snapshot management systems
+ * - Integrate with different runtime environments (Node.js, Next.js, etc.)
+ *
+ * ## Design Philosophy
+ *
+ * - **Exception-based**: Store operations throw exceptions on errors
+ * - **Result types available**: Optional Result pattern for consumers who prefer it
+ * - **TTL-based expiration**: Automatic data invalidation after configured time
+ * - **Size limits**: Prevents memory overflow with configurable limits
+ * - **Type-safe**: Full TypeScript support with discriminated unions
+ *
+ * @example
+ * ```typescript
+ * import { PrototypeInMemoryStore } from 'promidas/store';
+ *
+ * const store = new PrototypeInMemoryStore({
+ *   ttlMs: 30 * 60 * 1000, // 30 minutes
+ *   maxDataSizeBytes: 50 * 1024 * 1024, // 50MB
+ * });
+ *
+ * // Store data (throws on error)
+ * const snapshot = store.setAll(prototypes);
+ * console.log(`Stored ${snapshot.count} prototypes`);
+ *
+ * // Check if data is fresh
+ * if (!store.isExpired()) {
+ *   const prototype = store.getByPrototypeId('proto-123');
+ * }
+ *
+ * // Get statistics
+ * const stats = store.getStats();
+ * console.log(`Store size: ${stats.dataSizeBytes} bytes`);
+ * ```
+ *
+ * @module
+ * @see {@link ../repository/index.js} for high-level repository integration
+ */
+export { LIMIT_DATA_SIZE_BYTES, PrototypeInMemoryStore, type PrototypeInMemoryStats, type PrototypeInMemoryStoreConfig, type Snapshot as PrototypeInMemorySnapshot, } from './store.js';
+export { StoreError, ConfigurationError, DataSizeExceededError, SizeEstimationError, type StoreDataState, } from './errors/store-error.js';
+export type { SetResult, StoreErrorCode, StoreFailureKind, } from './types/index.js';
+export type { NormalizedPrototype } from '../types/index.js';
+export type { Logger, LogLevel } from '../logger/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/store/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAGH,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EACjC,KAAK,QAAQ,IAAI,yBAAyB,GAC3C,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EACV,SAAS,EACT,cAAc,EACd,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAG7D,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/store/index.js

@@ -0,0 +1,83 @@
+/**
+ * In-Memory Prototype Storage Module.
+ *
+ * This module provides a complete storage layer for managing in-memory snapshots
+ * of prototype data, including TTL-based expiration, size limits, and efficient
+ * ID-based lookups. It can be used as a standalone module for custom caching
+ * solutions or integrated with the repository layer.
+ *
+ * ## Core Components
+ *
+ * - {@link PrototypeInMemoryStore} — Main store class with snapshot management, TTL expiration, and ID-based lookups.
+ * - {@link PrototypeInMemoryStoreConfig} — Configuration options including TTL and max data size.
+ * - {@link PrototypeInMemoryStats} — Statistics and metadata about the current store state.
+ *
+ * ### Storage Operations & Result Types
+ *
+ * - {@link SetResult} — Discriminated union result type for `setAll` operations.
+ * - {@link StoreErrorCode} — Error codes for precise error classification.
+ * - {@link StoreFailureKind} — Failure kinds: `'storage_limit'`, `'serialization'`, or `'unknown'`.
+ *
+ * ### Error Handling
+ *
+ * The store throws exceptions by default, but also provides Result types for
+ * consumers who prefer explicit error handling:
+ *
+ * - {@link StoreError} — Base error class for all store errors.
+ * - {@link ConfigurationError} — Configuration validation errors.
+ * - {@link DataSizeExceededError} — Data size limit exceeded.
+ * - {@link SizeEstimationError} — Size estimation failures.
+ * - {@link StoreDataState} — Data state after operation: `'UNCHANGED'`, `'CLEARED'`, or `'UNKNOWN'`.
+ *
+ * ### Dependencies
+ *
+ * - {@link NormalizedPrototype} — The data type stored in the store.
+ * - {@link Logger} — Logger interface for custom logging implementations.
+ * - {@link LogLevel} — Log level type for controlling logger verbosity.
+ *
+ * ## Standalone Usage
+ *
+ * This module is designed to work independently, allowing you to:
+ * - Create custom in-memory caching solutions
+ * - Build data snapshot management systems
+ * - Integrate with different runtime environments (Node.js, Next.js, etc.)
+ *
+ * ## Design Philosophy
+ *
+ * - **Exception-based**: Store operations throw exceptions on errors
+ * - **Result types available**: Optional Result pattern for consumers who prefer it
+ * - **TTL-based expiration**: Automatic data invalidation after configured time
+ * - **Size limits**: Prevents memory overflow with configurable limits
+ * - **Type-safe**: Full TypeScript support with discriminated unions
+ *
+ * @example
+ * ```typescript
+ * import { PrototypeInMemoryStore } from 'promidas/store';
+ *
+ * const store = new PrototypeInMemoryStore({
+ *   ttlMs: 30 * 60 * 1000, // 30 minutes
+ *   maxDataSizeBytes: 50 * 1024 * 1024, // 50MB
+ * });
+ *
+ * // Store data (throws on error)
+ * const snapshot = store.setAll(prototypes);
+ * console.log(`Stored ${snapshot.count} prototypes`);
+ *
+ * // Check if data is fresh
+ * if (!store.isExpired()) {
+ *   const prototype = store.getByPrototypeId('proto-123');
+ * }
+ *
+ * // Get statistics
+ * const stats = store.getStats();
+ * console.log(`Store size: ${stats.dataSizeBytes} bytes`);
+ * ```
+ *
+ * @module
+ * @see {@link ../repository/index.js} for high-level repository integration
+ */
+// Core Store
+export { LIMIT_DATA_SIZE_BYTES, PrototypeInMemoryStore, } from './store.js';
+// Errors
+export { StoreError, ConfigurationError, DataSizeExceededError, SizeEstimationError, } from './errors/store-error.js';
+//# sourceMappingURL=index.js.map

package/dist/store/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/store/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAEH,aAAa;AACb,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GAIvB,MAAM,YAAY,CAAC;AAEpB,SAAS;AACT,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,GAEpB,MAAM,yBAAyB,CAAC"}