@conduit-client/type-normalization 2.0.0

package/LICENSE.txt

@@ -0,0 +1,27 @@
+*Attorney/Client Privileged + Confidential*
+
+Terms of Use for Public Code (Non-OSS)
+
+*NOTE:* Before publishing code under this license/these Terms of Use, please review https://salesforce.quip.com/WFfvAMKB18AL and confirm that you’ve completed all prerequisites described therein. *These Terms of Use may not be used or modified without input from IP and Product Legal.*
+
+*Terms of Use*
+
+Copyright 2022 Salesforce, Inc. All rights reserved. 
+
+These Terms of Use govern the download, installation, and/or use of this software provided by Salesforce, Inc. (“Salesforce”) (the “Software”), were last updated on April 15, 2022, ** and constitute a legally binding agreement between you and Salesforce. If you do not agree to these Terms of Use, do not install or use the Software. 
+ 
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the Software and derivative works subject to these Terms. These Terms shall be included in all copies or substantial portions of the Software. 
+
+Subject to the limited rights expressly granted hereunder, Salesforce reserves all rights, title, and interest in and to all intellectual property subsisting in the Software. No rights are granted to you hereunder other than as expressly set forth herein. Users residing in countries on the United States Office of Foreign Assets Control sanction list, or which are otherwise subject to a US export embargo, may not use the Software.
+ 
+Implementation of the Software may require development work, for which you are responsible. The Software may contain bugs, errors and incompatibilities and is made available on an AS IS basis without support, updates, or service level commitments. 
+ 
+Salesforce reserves the right at any time to modify, suspend, or discontinue, the Software (or any part thereof) with or without notice. You agree that Salesforce shall not be liable to you or to any third party for any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or proceeding made or brought against Salesforce by a third party arising out of or accruing from (a) your use of the Software, and (b) any application you develop with the Software that infringes any copyright, trademark, trade secret, trade dress, patent, or other intellectual property right of any person or defames any person or violates their rights of publicity or privacy (each a “Claim Against Salesforce”), and will indemnify Salesforce from any damages, attorney fees, and costs finally awarded against Salesforce as a result of, or for any amounts paid by Salesforce under a settlement approved by you in writing of, a Claim Against Salesforce, provided Salesforce (x) promptly gives you written notice of the Claim Against Salesforce, (y) gives you sole control of the defense and settlement of the Claim Against Salesforce (except that you may not settle any Claim Against Salesforce unless it unconditionally releases Salesforce of all liability), and (z) gives you all reasonable assistance, at your expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA, OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ 
+These Terms of Use shall be governed exclusively by the internal laws of the State of California, without regard to its conflicts of laws rules. Each party hereby consents to the exclusive jurisdiction of the state and federal courts located in San Francisco County, California to adjudicate any dispute arising out of or relating to these Terms of Use and the download, installation, and/or use of the Software. Except as expressly stated herein, these Terms of Use constitute the entire agreement between the parties, and supersede all prior and contemporaneous agreements, proposals, or representations, written or oral, concerning their subject matter. No modification, amendment, or waiver of any provision of these Terms of Use shall be effective unless it is by an update to these Terms of Use that Salesforce makes available, or is in writing and signed by the party against whom the modification, amendment, or waiver is to be asserted.
+
+_*Data Privacy*_: Salesforce may collect, process, and store device, system, and other information related to your use of the Software. This information includes, but is not limited to, IP address, user metrics, and other data (“Usage Data”). Salesforce may use Usage Data for analytics, product development, and marketing purposes. You acknowledge that files generated in conjunction with the Software may contain sensitive or confidential data, and you are solely responsible for anonymizing and protecting such data.  

package/README.md

@@ -0,0 +1 @@
+This software is provided as-is with no support provided.

package/dist/main/index.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/types/v1/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/__tests__/regex-performance.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/__tests__/type-utils.d.ts

@@ -0,0 +1,140 @@
+import { Cache, CanonicalCacheControlMetadata, ReadonlyCache } from '@conduit-client/service-cache/v1';
+import { Result, Err } from '@conduit-client/utils';
+import { IdentifiableTypeRepository, FlattenedKeySelfIdentifiableTypeRepository, NormalizedLink, TypeRepository, WriteErrors, WriteInput, ReadErrors, DenormalizeDataInput, ReadInput, WriteResult, ReadResult, NormalizeDataInput } from '..';
+import type { NamedCacheControllerService } from '@conduit-client/service-cache-control/v1';
+import { NamedPubSubService } from '@conduit-client/service-pubsub/v1';
+import { NamedInstrumentationService } from '@conduit-client/service-instrumentation/v1';
+type City = {
+    id: string;
+    name: string;
+};
+export type AuthorBio = {
+    hometown: City;
+    publisher: string;
+    birthdate: string;
+};
+type AuthorBioNormalized = AuthorBio;
+export type Author = {
+    id: string;
+    name: string;
+    bio: AuthorBio;
+};
+type AuthorNormalized = {
+    id: string;
+    name: string;
+    bio: AuthorBioNormalized;
+};
+export type Post = {
+    id: number;
+    title: string;
+    text: string;
+    author: Author;
+};
+type PostNormalized = {
+    id: number;
+    title: string;
+    text: string;
+    author: NormalizedLink;
+};
+export type PostList = {
+    list: Post[];
+};
+type PostListNormalized = {
+    list: NormalizedLink[];
+};
+export declare class ExampleModuleTypeRegistry {
+    protected now: number;
+    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
+    protected types: {
+        authorBio: AuthorBioType;
+        author: AuthorType;
+        post: PostType;
+        postList: PostListType;
+        getPostListById200JsonType: GetPostListById200JsonType;
+    };
+    constructor(now: number, services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>);
+    get authorBio(): AuthorBioType;
+    get author(): AuthorType;
+    get post(): PostType;
+    get postList(): PostListType;
+    get getPostListById200JsonType(): GetPostListById200JsonType;
+}
+declare class AuthorBioType implements TypeRepository<AuthorBio, AuthorBioNormalized, AuthorBioNormalized, AuthorBio> {
+    protected services: {};
+    protected typeRegistry: ExampleModuleTypeRegistry;
+    namespace: string;
+    typeName: string;
+    constructor(services: {}, typeRegistry: ExampleModuleTypeRegistry);
+    write(_cache: Cache, data: AuthorBio): WriteResult<AuthorBioNormalized>;
+    read(_cache: ReadonlyCache, data: AuthorBioNormalized): ReadResult<AuthorBio>;
+    equals(x: AuthorBio, y: AuthorBio): boolean;
+}
+type AuthorKeyParams = {
+    id: string;
+};
+type AuthorWriteInput = WriteInput<Author>;
+type AuthorNormalizeDataInput = NormalizeDataInput<Author, AuthorNormalized>;
+type AuthorDenormalizeDataInput = DenormalizeDataInput<AuthorNormalized>;
+declare class AuthorType extends FlattenedKeySelfIdentifiableTypeRepository<Author, AuthorNormalized, AuthorKeyParams> {
+    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
+    protected typeRegistry: ExampleModuleTypeRegistry;
+    namespace: string;
+    typeName: string;
+    cacheControl: CanonicalCacheControlMetadata;
+    keySchema: string[];
+    constructor(services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>, typeRegistry: ExampleModuleTypeRegistry);
+    protected normalizeData(cache: Cache, input: AuthorNormalizeDataInput): Result<AuthorNormalized, WriteErrors>;
+    buildKeyParams(input: AuthorWriteInput): AuthorKeyParams;
+    protected denormalizeData(cache: ReadonlyCache, input: AuthorDenormalizeDataInput): Result<Author, ReadErrors>;
+}
+type PostKeyParams = {
+    id: number;
+};
+type PostWriteInput = WriteInput<Post>;
+type PostNormalizeDataInput = NormalizeDataInput<Post, PostNormalized>;
+type PostDenormalizeDataInput = DenormalizeDataInput<PostNormalized>;
+declare class PostType extends FlattenedKeySelfIdentifiableTypeRepository<Post, PostNormalized, PostKeyParams> {
+    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
+    protected typeRegistry: ExampleModuleTypeRegistry;
+    namespace: string;
+    typeName: string;
+    cacheControl: CanonicalCacheControlMetadata;
+    constructor(services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>, typeRegistry: ExampleModuleTypeRegistry);
+    keySchema: string[];
+    protected normalizeData(cache: Cache, input: PostNormalizeDataInput): Result<PostNormalized, WriteErrors>;
+    buildKeyParams(input: PostWriteInput): PostKeyParams;
+    protected denormalizeData(cache: ReadonlyCache, input: PostDenormalizeDataInput): Result<Post, ReadErrors>;
+}
+type PostListWriteInput = NormalizeDataInput<PostList, PostListNormalized>;
+type PostListReadInput = DenormalizeDataInput<PostListNormalized>;
+declare class PostListType implements TypeRepository<PostList, PostListReadInput, PostListNormalized, PostListWriteInput> {
+    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
+    protected typeRegistry: ExampleModuleTypeRegistry;
+    namespace: string;
+    typeName: string;
+    constructor(services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>, typeRegistry: ExampleModuleTypeRegistry);
+    write(cache: Cache, input: PostListWriteInput): Result<PostListNormalized, WriteErrors>;
+    read(cache: ReadonlyCache, input: PostListReadInput): Result<PostList, ReadErrors>;
+    equals(x: PostList, y: PostList): boolean;
+}
+type GetPostListKeyParams = {
+    id: string;
+};
+type GetPostListReadInput = ReadInput;
+type GetPostListWriteInput = WriteInput<PostList, {
+    keyParams: GetPostListKeyParams;
+}>;
+type GetPostListNormalizeDataInput = NormalizeDataInput<PostList, PostListNormalized>;
+type GetPostListDenormalizeDataInput = DenormalizeDataInput<PostListNormalized>;
+declare class GetPostListById200JsonType extends IdentifiableTypeRepository<PostList, PostListNormalized, GetPostListKeyParams, GetPostListReadInput, GetPostListWriteInput> {
+    protected services: {};
+    protected typeRegistry: ExampleModuleTypeRegistry;
+    namespace: string;
+    typeName: string;
+    cacheControl: CanonicalCacheControlMetadata;
+    constructor(services: {}, typeRegistry: ExampleModuleTypeRegistry);
+    buildKeyParams(input: GetPostListWriteInput): GetPostListKeyParams;
+    protected normalizeData(cache: Cache, input: GetPostListNormalizeDataInput): Err<never, WriteErrors> | import("@conduit-client/utils").Ok<PostListNormalized, never>;
+    protected denormalizeData(cache: ReadonlyCache, input: GetPostListDenormalizeDataInput): Result<PostList, ReadErrors>;
+}
+export {};

package/dist/types/v1/index.d.ts

@@ -0,0 +1,243 @@
+import { type Result } from '@conduit-client/utils';
+import type { Key, CanonicalCacheControlMetadata, ReadonlyCache, CacheEntry, Cache } from '@conduit-client/service-cache/v1';
+import { NamedPubSubService } from '@conduit-client/service-pubsub/v1';
+import { InstrumentationAttributes, NamedInstrumentationService } from '@conduit-client/service-instrumentation/v1';
+import { NamedCacheControllerService } from '@conduit-client/service-cache-control/v1';
+export interface NormalizedLink {
+    type: 'link';
+    linkedKey: Key;
+}
+type UnknownError = {
+    type: 'unknown';
+    error: Error;
+};
+/**
+ * An error that occurs when a type tries to read from the cache, and the cache metadata does
+ * not match the current type
+ */
+type IncorrectTypeError = {
+    type: 'incorrectType';
+    expectedType: string;
+    actualType: string;
+};
+/**
+ * An error that occurs when a type tries to read from the cache and data is missing
+ */
+type MissingDataError = {
+    type: 'missingData';
+    namespace: string;
+    typeName: string;
+    data: unknown;
+};
+/**
+ * A union of errors that can be returned during the write process
+ */
+export type WriteErrors = Array<UnknownError>;
+/**
+ * A union of errors that can be returned during the read process
+ */
+export type ReadErrors = Array<UnknownError | IncorrectTypeError | MissingDataError>;
+export type ReadResult<Data> = Result<Data, ReadErrors>;
+export type WriteResult<Data> = Result<Data, WriteErrors>;
+/**
+ * A Type defines a collection of functions associated with a particular
+ * data type. Types are not normalized but may contain normalized data.
+ *
+ * @typeParam Data TypeScript type that corresponds to the data
+ * @typeParam NormalizedData TypeScript type that corresponds to the normalized data
+ * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data
+ */
+export type TypeRepository<Data, ReadInput, WriteResponse, WriteInput> = {
+    readonly namespace: string;
+    readonly typeName: string;
+    equals(x: Data, y: Data): boolean;
+    /**
+     * Normalizes data for storage.
+     */
+    write(cache: Cache, input: WriteInput): WriteResult<WriteResponse>;
+    /**
+     * De-normalizes a Type's data. A type could normalize into a Link, or return Data to the caller.
+     * A caller must not be relying on the referenced type being normalized or not.
+     * If denormalization fails, it will return undefined.
+     */
+    read(cache: ReadonlyCache, input: ReadInput): ReadResult<Data>;
+};
+/**
+ * An InvalidatableType defines an invalidate function that takes a generic input,
+ * and returns a promise that resolves when the invalidation is complete
+ *
+ * @typeParam T is another type to extend
+ * @typeParam InvalidateInput is the input to run an invalidation
+ */
+export type Invalidatable<T extends TypeRepository<any, any, any, any>, InvalidateInput> = T & {
+    /**
+     *
+     * @param configs Partial KeyConfigs for this Type (partial KeyConfig treats missing parts as wildcard)
+     */
+    invalidate(configs: InvalidateInput[]): Promise<void>;
+};
+/**
+ * A QueryableType defines a collection of functions associated with a particular
+ * data type that gets its own cache entry.
+ *
+ * @typeParam Data TypeScript type that corresponds to the data
+ * @typeParam KeyConfig TypeScript type for the inputs needed to construct
+ *   a Key for the data
+ * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data
+ */
+export type Queryable<T extends TypeRepository<any, any, any, any>, QueryInput> = T & {
+    /**
+     *
+     * @param cache The cache to run the query against
+     * @param query The query to run
+     */
+    query(cache: Cache, query: QueryInput): ReadResult<DataOf<T>>;
+};
+export type DataOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<infer Data, any, any, any> ? Data : never;
+export type ReadInputOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, infer ReadInput, any, any> ? ReadInput : never;
+export type WriteResponseOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, any, infer WriteResponse, any> ? WriteResponse : never;
+export type WriteResultOf<T extends TypeRepository<any, any, any, any>> = WriteResult<WriteResponseOf<T>>;
+export type WriteInputOf<T extends TypeRepository<any, any, any, any>> = T extends TypeRepository<any, any, any, infer WriteInput> ? WriteInput : never;
+export type InvalidateInputOf<T extends TypeRepository<any, any, any, any>> = T extends Invalidatable<any, infer InvalidateInput> ? InvalidateInput : never;
+/**
+ * A utility method for ensuring that a given entry in the cache matches a type based on namespace and name information
+ * @param cacheEntry the cache entry to validate against
+ * @param type the type to validate the cache entry against
+ * @returns
+ */
+export declare function isCacheEntryForType(cacheEntry: CacheEntry<unknown>, type: TypeRepository<unknown, unknown, unknown, unknown>): boolean;
+export type KeyParamsOf<T> = T extends IdentifiableTypeRepository<any, any, infer KeyParams, any, any> ? KeyParams : never;
+export type WriteInput<Data, Extension = Record<string, unknown>> = {
+    data: Data;
+} & Extension;
+export type NormalizeDataInput<Data, NormalizedData, Extension extends Record<string, any> = Record<string, unknown>> = WriteInput<Data, Extension & {
+    existingNormalizedData?: NormalizedData;
+}>;
+export type ReadInput<Extension extends Record<string, any> = Record<string, unknown>> = {
+    normalizedData: NormalizedLink;
+} & Extension;
+export type ReadByKeyParamsInput<KeyParams> = {
+    keyParams: KeyParams;
+};
+export type DenormalizeInput<Extension extends Record<string, any> = Record<string, unknown>> = Extension & {
+    key: Key;
+};
+export type DenormalizeDataInput<NormalizedData, Extension extends Record<string, any> = Record<string, unknown>> = Extension & {
+    normalizedData: NormalizedData;
+};
+export type KeyParamQuery<KeyParams, ReadInputExtension> = {
+    type: 'keyParams';
+    keyParams: KeyParams;
+} & ReadInputExtension;
+export type QueryFor<T> = T extends Queryable<any, infer Query> ? Query : never;
+/**
+ * An abstract base class that implements Type, defining additional abstract properties and methods
+ * for building a key for a given set of parameters, and defining the canonical cache control metadata
+ * for any data written
+ */
+export declare abstract class IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension extends Record<string, any> = Record<string, unknown>, WriteInputExtension extends Record<string, any> = Record<string, unknown>, Query extends KeyParamQuery<KeyParams, ReadInputExtension> = KeyParamQuery<KeyParams, ReadInputExtension>> implements Queryable<TypeRepository<Data, ReadInput<ReadInputExtension>, NormalizedLink, WriteInput<Data, WriteInputExtension>>, Query> {
+    protected services: {};
+    constructor(services: {});
+    abstract readonly cacheControl: CanonicalCacheControlMetadata;
+    abstract readonly namespace: string;
+    abstract readonly typeName: string;
+    protected abstract denormalizeData(cache: ReadonlyCache, input: DenormalizeDataInput<NormalizedData, ReadInput<ReadInputExtension>>): Result<Data, ReadErrors>;
+    protected abstract normalizeData(cache: Cache, input: NormalizeDataInput<Data, NormalizedData, WriteInputExtension & {
+        existingNormalizedData?: NormalizedData;
+    }>): Result<NormalizedData, WriteErrors>;
+    get cacheMetadata(): {
+        cacheControl: {
+            type: "max-age";
+            maxAge: number;
+        } | {
+            type: "stale-while-revalidate";
+            maxAge: number;
+            staleTime: number;
+        } | {
+            type: "no-cache";
+        } | {
+            type: "no-store";
+        };
+        type: {
+            namespace: string;
+            name: string;
+        };
+    };
+    buildKey(params: KeyParams): Key;
+    abstract buildKeyParams(input: WriteInput<Data, WriteInputExtension>): KeyParams;
+    write(cache: Cache, input: WriteInput<Data, WriteInputExtension>): WriteResult<NormalizedLink>;
+    protected validateEntry(entry: CacheEntry<unknown>): Result<undefined, ReadErrors>;
+    query(cache: Cache, query: Query): ReadResult<Data>;
+    read(cache: ReadonlyCache, input: ReadInput<ReadInputExtension>): Result<Data, ReadErrors>;
+    denormalize(cache: ReadonlyCache, input: DenormalizeInput<ReadInput<ReadInputExtension>>): Result<Data, ReadErrors>;
+    equals(x: Data, y: Data): boolean;
+    buildMissingDataError(): MissingDataError;
+}
+/**
+ * An abstract base class that extends IdentifiableType, adding the additional constraint that the
+ * only data required to write to the cache is an instance of the data itself, i.e. the identity of
+ * the data lives inside the data
+ */
+export declare abstract class SelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension extends Record<string, any> = Record<string, unknown>, WriteInputExtension extends Record<string, any> = Record<string, unknown>> extends IdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension> {
+}
+/**
+ * An abstract base class that extends SelfIdentifiableType. Adds the constraint that the structure of
+ * the key parameters must be a flat object, with no objects nested. This class provides invalidation and keybuilding 'for free'.
+ * Should be preferred over IdentifiableType and SelfIdentifiableType
+ */
+export declare abstract class FlattenedKeySelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams extends FlattenedKeyParams, ReadInputExtension extends Record<string, any> = Record<string, unknown>, WriteInputExtension extends Record<string, any> = Record<string, unknown>> extends SelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension> implements Invalidatable<SelfIdentifiableTypeRepository<Data, NormalizedData, KeyParams, ReadInputExtension, WriteInputExtension>, Partial<KeyParams>> {
+    protected services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>;
+    instrumentationAttributes: InstrumentationAttributes | undefined;
+    constructor(services: NamedCacheControllerService & NamedPubSubService & Partial<NamedInstrumentationService>);
+    abstract readonly keySchema: string[];
+    invalidate(configs: Partial<KeyParams>[]): Promise<void>;
+    protected collectInstrumentation(duration: number): void;
+    protected runInvalidate(configs: Partial<KeyParams>[]): Promise<void>;
+    buildKey(config: KeyParams): Key;
+}
+type ScalarKeyValue = string | number | boolean | null | undefined;
+type FlattenedKeyParams = Record<string, ScalarKeyValue | ScalarKeyValue[]>;
+export declare function buildNamespacedTypeKey(namespace: string, typeName: string, keyConfig: FlattenedKeyParams, keySchema: string[]): string;
+export declare function buildRegexForNamespacedKeys(namespace: string, typeName: string, partialKeyConfigs: Array<FlattenedKeyParams>, keySchema: string[]): RegExp;
+export declare function extractReadWriteData<Data>(result: ReadResult<Data> | WriteResult<Data>, errorCollector: any[]): Data | undefined;
+export declare function buildReadWriteResult<Data, Errors extends WriteErrors | ReadErrors>(data: unknown, errors: Errors): Result<Data, Errors>;
+export type UnionRepresentation<Discriminator extends string, Data> = {
+    discriminator: Discriminator;
+    data: Data;
+};
+export type DiscriminatorMap<Discriminator extends string, Data, Normalized> = {
+    [k in Discriminator]: {
+        data: Data;
+        normalized: Normalized;
+    };
+};
+export type NormalizedRepresentationOf<M extends DiscriminatorMap<any, any, any>> = M extends DiscriminatorMap<infer D, any, any> ? {
+    [k in D]: UnionRepresentation<k, M[k]['normalized']>;
+}[D] : never;
+export type DenormalizeMapOf<M extends DiscriminatorMap<any, any, any>> = M extends DiscriminatorMap<infer D, any, any> ? {
+    [k in D]: (normalized: M[k]['normalized']) => M[k]['data'];
+} : never;
+export type UnionDataOf<M extends DiscriminatorMap<any, any, any>> = M extends DiscriminatorMap<any, infer D, any> ? D : never;
+export type DiscriminatorOf<M extends DiscriminatorMap<any, any, any>> = M extends DiscriminatorMap<infer D, any, any> ? D : never;
+export type DiscriminatorNormalizeFunctionsMap<M extends DiscriminatorMap<any, any, any>> = M extends DiscriminatorMap<infer D, any, any> ? {
+    [k in D]: {
+        test: (data: M[D]['data']) => boolean;
+        normalize: (data: M[k]['data']) => M[k]['normalized'];
+    };
+} : never;
+/**
+ *
+ * @param normalized The normalized data representation, including the discriminator value
+ * @param denormalizeMap A map of discriminator -> denormalize functions to be used based on the datas discriminator
+ * @returns
+ */
+export declare function denormalizeUnionRepresentation<M extends DiscriminatorMap<string, unknown, unknown>>(normalized: NormalizedRepresentationOf<M>, denormalizeMap: DenormalizeMapOf<M>): UnionDataOf<M>;
+/**
+ *
+ * @param data The canonical/denormalized data representation
+ * @param normalizeTestMap A map of discriminator to test method which return a boolean indicating if the data adheres to this "discriminator"
+ * and a normalize function to call if the data matches this discriminator
+ * @returns
+ */
+export declare function normalizeUnionRepresentation<M extends DiscriminatorMap<string, unknown, unknown>>(data: UnionDataOf<M>, normalizeTestMap: DiscriminatorNormalizeFunctionsMap<M>): NormalizedRepresentationOf<M>;
+export {};

package/dist/v1/index.js

@@ -0,0 +1,202 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { stableJSONStringify, err, ok, deepEquals, ArrayIsArray } from "@conduit-client/utils";
+function isCacheEntryForType(cacheEntry, type) {
+  return cacheEntry.metadata.type.namespace === type.namespace && cacheEntry.metadata.type.name === type.typeName;
+}
+class IdentifiableTypeRepository {
+  constructor(services) {
+    this.services = services;
+  }
+  get cacheMetadata() {
+    return {
+      cacheControl: { ...this.cacheControl },
+      type: { namespace: this.namespace, name: this.typeName }
+    };
+  }
+  buildKey(params) {
+    return `${this.namespace}::${this.typeName}(${stableJSONStringify(params)})`;
+  }
+  write(cache, input) {
+    var _a;
+    const key = this.buildKey(this.buildKeyParams(input));
+    const existingNormalizedData = (_a = cache.get(key)) == null ? void 0 : _a.value;
+    const normalized = this.normalizeData(cache, { ...input, existingNormalizedData });
+    if (normalized.isErr()) {
+      return err(normalized.error);
+    }
+    cache.set(key, {
+      value: normalized.value,
+      metadata: this.cacheMetadata
+    });
+    return ok({
+      type: "link",
+      linkedKey: key
+    });
+  }
+  validateEntry(entry) {
+    if (!isCacheEntryForType(entry, this)) {
+      return err([
+        {
+          type: "incorrectType",
+          expectedType: this.typeName,
+          actualType: entry.metadata.type.name
+        }
+      ]);
+    }
+    return ok(void 0);
+  }
+  query(cache, query) {
+    return this.read(cache, {
+      ...query,
+      normalizedData: { type: "link", linkedKey: this.buildKey(query.keyParams) }
+    });
+  }
+  read(cache, input) {
+    return this.denormalize(cache, { ...input, key: input.normalizedData.linkedKey });
+  }
+  denormalize(cache, input) {
+    const cacheEntry = cache.get(input.key, {
+      copy: false
+    });
+    if (cacheEntry) {
+      const validationResult = this.validateEntry(cacheEntry);
+      if (validationResult.isErr()) {
+        return err([...validationResult.error]);
+      }
+      const normalizedData = cacheEntry.value;
+      return this.denormalizeData(cache, { ...input, normalizedData });
+    }
+    return err([this.buildMissingDataError()]);
+  }
+  equals(x, y) {
+    return deepEquals(x, y);
+  }
+  buildMissingDataError() {
+    return {
+      type: "missingData",
+      typeName: this.typeName,
+      namespace: this.namespace,
+      data: void 0
+    };
+  }
+}
+class SelfIdentifiableTypeRepository extends IdentifiableTypeRepository {
+}
+class FlattenedKeySelfIdentifiableTypeRepository extends SelfIdentifiableTypeRepository {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  async invalidate(configs) {
+    const startTime = this.services.instrumentation ? this.services.instrumentation.currentTimeMs() : 0;
+    const result = this.runInvalidate(configs).then(() => {
+      if (this.services.instrumentation) {
+        const duration = this.services.instrumentation.currentTimeMs() - startTime;
+        this.collectInstrumentation(duration);
+      }
+    });
+    return result;
+  }
+  collectInstrumentation(duration) {
+    if (this.services.instrumentation) {
+      const meter = this.services.instrumentation.metrics.getMeter("onestore");
+      const attributes = {
+        ...this.instrumentationAttributes,
+        namespace: this.namespace,
+        typeName: this.typeName
+      };
+      meter.createCounter(`type.invalidate.count`).add(1, attributes);
+      meter.createHistogram(`type.invalidate.duration`).record(duration, attributes);
+    }
+  }
+  async runInvalidate(configs) {
+    const regex = buildRegexForNamespacedKeys(
+      this.namespace,
+      this.typeName,
+      configs,
+      this.keySchema
+    );
+    const results = /* @__PURE__ */ new Set();
+    for await (const entry of this.services.cacheController.findAndModify(
+      { key: { $regex: regex } },
+      { type: "invalidate" }
+    )) {
+      results.add(entry);
+    }
+    if (results.size > 0) {
+      await this.services.pubSub.publish({
+        type: "cacheInvalidation",
+        data: results
+      });
+    }
+  }
+  buildKey(config) {
+    return buildNamespacedTypeKey(this.namespace, this.typeName, config, this.keySchema);
+  }
+}
+function buildNamespacedTypeKey(namespace, typeName, keyConfig, keySchema) {
+  const keyParts = keySchema.map((key) => {
+    const value = keyConfig[key];
+    return `${ArrayIsArray(value) ? value.join() : value}`;
+  }).join("|");
+  return `${namespace}::${typeName}(${keyParts})`;
+}
+function buildRegexForNamespacedKeys(namespace, typeName, partialKeyConfigs, keySchema) {
+  const patterns = partialKeyConfigs.map((partial) => {
+    const requiredParts = keySchema.map((key) => {
+      if (!(key in partial)) {
+        return `[^|]*?`;
+      }
+      const value = partial[key];
+      return `(?:${(ArrayIsArray(value) ? value.join() : String(value)).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`;
+    }).join("\\|");
+    return `^${namespace}::${typeName}\\((?:${requiredParts})\\)$`;
+  });
+  return new RegExp(`^(?:${patterns.join("|")})$`);
+}
+function extractReadWriteData(result, errorCollector) {
+  if (result.isOk()) {
+    return result.value;
+  }
+  errorCollector.push(...result.error);
+  return void 0;
+}
+function buildReadWriteResult(data, errors) {
+  if (errors.length > 0) {
+    return err(errors);
+  }
+  return ok(data);
+}
+function denormalizeUnionRepresentation(normalized, denormalizeMap) {
+  const discriminator = normalized.discriminator;
+  return denormalizeMap[discriminator](normalized.data);
+}
+function normalizeUnionRepresentation(data, normalizeTestMap) {
+  for (const discriminator of Object.keys(normalizeTestMap)) {
+    const discriminatorLogic = normalizeTestMap[discriminator];
+    if (discriminatorLogic.test(data)) {
+      return {
+        discriminator,
+        data: discriminatorLogic.normalize(data)
+      };
+    }
+  }
+  throw new Error("No matching union member found");
+}
+export {
+  FlattenedKeySelfIdentifiableTypeRepository,
+  IdentifiableTypeRepository,
+  SelfIdentifiableTypeRepository,
+  buildNamespacedTypeKey,
+  buildReadWriteResult,
+  buildRegexForNamespacedKeys,
+  denormalizeUnionRepresentation,
+  extractReadWriteData,
+  isCacheEntryForType,
+  normalizeUnionRepresentation
+};
+//# sourceMappingURL=index.js.map

package/dist/v1/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/v1/index.ts"],"sourcesContent":["import { type Result, ok, err, deepEquals, stableJSONStringify } from '@conduit-client/utils';\nimport type {\n    Key,\n    CanonicalCacheControlMetadata,\n    ReadonlyCache,\n    CacheEntry,\n    Cache,\n} from '@conduit-client/service-cache/v1';\n\nimport { ArrayIsArray } from '@conduit-client/utils';\nimport { NamedPubSubService } from '@conduit-client/service-pubsub/v1';\nimport {\n    InstrumentationAttributes,\n    NamedInstrumentationService,\n} from '@conduit-client/service-instrumentation/v1';\nimport { NamedCacheControllerService } from '@conduit-client/service-cache-control/v1';\n\nexport interface NormalizedLink {\n    type: 'link';\n    linkedKey: Key;\n}\n\ntype UnknownError = {\n    type: 'unknown';\n    error: Error;\n};\n\n/**\n * An error that occurs when a type tries to read from the cache, and the cache metadata does\n * not match the current type\n */\ntype IncorrectTypeError = {\n    type: 'incorrectType';\n    expectedType: string;\n    actualType: string;\n};\n\n/**\n * An error that occurs when a type tries to read from the cache and data is missing\n */\ntype MissingDataError = {\n    type: 'missingData';\n    namespace: string;\n    typeName: string;\n    data: unknown;\n};\n\n/**\n * A union of errors that can be returned during the write process\n */\nexport type WriteErrors = Array<UnknownError>;\n\n/**\n * A union of errors that can be returned during the read process\n */\nexport type ReadErrors = Array<UnknownError | IncorrectTypeError | MissingDataError>;\n\nexport type ReadResult<Data> = Result<Data, ReadErrors>;\nexport type WriteResult<Data> = Result<Data, WriteErrors>;\n\n/**\n * A Type defines a collection of functions associated with a particular\n * data type. Types are not normalized but may contain normalized data.\n *\n * @typeParam Data TypeScript type that corresponds to the data\n * @typeParam NormalizedData TypeScript type that corresponds to the normalized data\n * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data\n */\nexport type TypeRepository<Data, ReadInput, WriteResponse, WriteInput> = {\n    readonly namespace: string;\n    readonly typeName: string;\n\n    equals(x: Data, y: Data): boolean;\n\n    /**\n     * Normalizes data for storage.\n     */\n    write(cache: Cache, input: WriteInput): WriteResult<WriteResponse>;\n\n    /**\n     * De-normalizes a Type's data. A type could normalize into a Link, or return Data to the caller.\n     * A caller must not be relying on the referenced type being normalized or not.\n     * If denormalization fails, it will return undefined.\n     */\n    read(cache: ReadonlyCache, input: ReadInput): ReadResult<Data>;\n};\n\n/**\n * An InvalidatableType defines an invalidate function that takes a generic input,\n * and returns a promise that resolves when the invalidation is complete\n *\n * @typeParam T is another type to extend\n * @typeParam InvalidateInput is the input to run an invalidation\n */\nexport type Invalidatable<T extends TypeRepository<any, any, any, any>, InvalidateInput> = T & {\n    /**\n     *\n     * @param configs Partial KeyConfigs for this Type (partial KeyConfig treats missing parts as wildcard)\n     */\n    invalidate(configs: InvalidateInput[]): Promise<void>;\n};\n\n/**\n * A QueryableType defines a collection of functions associated with a particular\n * data type that gets its own cache entry.\n *\n * @typeParam Data TypeScript type that corresponds to the data\n * @typeParam KeyConfig TypeScript type for the inputs needed to construct\n *   a Key for the data\n * @typeParam NormalizeInputData TypeScript type that corresponds to the data that the normalize method expects as input. Defaults to the same as Data\n */\nexport type Queryable<T extends TypeRepository<any, any, any, any>, QueryInput> = T & {\n    /**\n     *\n     * @param cache The cache to run the query against\n     * @param query The query to run\n     */\n    query(cache: Cache, query: QueryInput): ReadResult<DataOf<T>>;\n};\n\nexport type DataOf<T extends TypeRepository<any, any, any, any>> =\n    T extends TypeRepository<infer Data, any, any, any> ? Data : never;\nexport type ReadInputOf<T extends TypeRepository<any, any, any, any>> =\n    T extends TypeRepository<any, infer ReadInput, any, any> ? ReadInput : never;\nexport type WriteResponseOf<T extends TypeRepository<any, any, any, any>> =\n    T extends TypeRepository<any, any, infer WriteResponse, any> ? WriteResponse : never;\nexport type WriteResultOf<T extends TypeRepository<any, any, any, any>> = WriteResult<\n    WriteResponseOf<T>\n>;\nexport type WriteInputOf<T extends TypeRepository<any, any, any, any>> =\n    T extends TypeRepository<any, any, any, infer WriteInput> ? WriteInput : never;\nexport type InvalidateInputOf<T extends TypeRepository<any, any, any, any>> =\n    T extends Invalidatable<any, infer InvalidateInput> ? InvalidateInput : never;\n\n/**\n * A utility method for ensuring that a given entry in the cache matches a type based on namespace and name information\n * @param cacheEntry the cache entry to validate against\n * @param type the type to validate the cache entry against\n * @returns\n */\nexport function isCacheEntryForType(\n    cacheEntry: CacheEntry<unknown>,\n    type: TypeRepository<unknown, unknown, unknown, unknown>\n): boolean {\n    return (\n        cacheEntry.metadata.type.namespace === type.namespace &&\n        cacheEntry.metadata.type.name === type.typeName\n    );\n}\n\nexport type KeyParamsOf<T> =\n    T extends IdentifiableTypeRepository<any, any, infer KeyParams, any, any> ? KeyParams : never;\n\nexport type WriteInput<Data, Extension = Record<string, unknown>> = { data: Data } & Extension;\nexport type NormalizeDataInput<\n    Data,\n    NormalizedData,\n    Extension extends Record<string, any> = Record<string, unknown>,\n> = WriteInput<Data, Extension & { existingNormalizedData?: NormalizedData }>;\n\nexport type ReadInput<Extension extends Record<string, any> = Record<string, unknown>> = {\n    normalizedData: NormalizedLink;\n} & Extension;\nexport type ReadByKeyParamsInput<KeyParams> = {\n    keyParams: KeyParams;\n};\nexport type DenormalizeInput<Extension extends Record<string, any> = Record<string, unknown>> =\n    Extension & {\n        key: Key;\n    };\nexport type DenormalizeDataInput<\n    NormalizedData,\n    Extension extends Record<string, any> = Record<string, unknown>,\n> = Extension & { normalizedData: NormalizedData };\n\nexport type KeyParamQuery<KeyParams, ReadInputExtension> = {\n    type: 'keyParams';\n    keyParams: KeyParams;\n} & ReadInputExtension;\nexport type QueryFor<T> = T extends Queryable<any, infer Query> ? Query : never;\n\n/**\n * An abstract base class that implements Type, defining additional abstract properties and methods\n * for building a key for a given set of parameters, and defining the canonical cache control metadata\n * for any data written\n */\nexport abstract class IdentifiableTypeRepository<\n    Data,\n    NormalizedData,\n    KeyParams,\n    ReadInputExtension extends Record<string, any> = Record<string, unknown>,\n    WriteInputExtension extends Record<string, any> = Record<string, unknown>,\n    Query extends KeyParamQuery<KeyParams, ReadInputExtension> = KeyParamQuery<\n        KeyParams,\n        ReadInputExtension\n    >,\n> implements\n        Queryable<\n            TypeRepository<\n                Data,\n                ReadInput<ReadInputExtension>,\n                NormalizedLink,\n                WriteInput<Data, WriteInputExtension>\n            >,\n            Query\n        >\n{\n    constructor(protected services: {}) {}\n    abstract readonly cacheControl: CanonicalCacheControlMetadata;\n    abstract readonly namespace: string;\n    abstract readonly typeName: string;\n    protected abstract denormalizeData(\n        cache: ReadonlyCache,\n        input: DenormalizeDataInput<NormalizedData, ReadInput<ReadInputExtension>>\n    ): Result<Data, ReadErrors>;\n    protected abstract normalizeData(\n        cache: Cache,\n        input: NormalizeDataInput<\n            Data,\n            NormalizedData,\n            WriteInputExtension & { existingNormalizedData?: NormalizedData }\n        >\n    ): Result<NormalizedData, WriteErrors>;\n    get cacheMetadata() {\n        return {\n            cacheControl: { ...this.cacheControl },\n            type: { namespace: this.namespace, name: this.typeName },\n        };\n    }\n\n    buildKey(params: KeyParams): Key {\n        return `${this.namespace}::${this.typeName}(${stableJSONStringify(params)})`;\n    }\n    abstract buildKeyParams(input: WriteInput<Data, WriteInputExtension>): KeyParams;\n\n    write(cache: Cache, input: WriteInput<Data, WriteInputExtension>): WriteResult<NormalizedLink> {\n        // Identifiable types can have a key that is not the same as the input normalized data\n        // so we need to build the key from the input, and then get the existing normalized data from the cache\n        // and pass it to the normalizeData method. This should ALWAYS be done for identifiable types.\n        const key = this.buildKey(this.buildKeyParams(input));\n        const existingNormalizedData: NormalizedData | undefined = cache.get<NormalizedData>(key)\n            ?.value as any;\n        const normalized = this.normalizeData(cache, { ...input, existingNormalizedData });\n        if (normalized.isErr()) {\n            return err(normalized.error);\n        }\n\n        cache.set<NormalizedData>(key, {\n            value: normalized.value,\n            metadata: this.cacheMetadata,\n        });\n\n        return ok({\n            type: 'link',\n            linkedKey: key,\n        } as const);\n    }\n\n    protected validateEntry(entry: CacheEntry<unknown>): Result<undefined, ReadErrors> {\n        if (!isCacheEntryForType(entry, this)) {\n            return err([\n                {\n                    type: 'incorrectType',\n                    expectedType: this.typeName,\n                    actualType: entry.metadata.type.name,\n                },\n            ]);\n        }\n        return ok(undefined);\n    }\n\n    query(cache: Cache, query: Query): ReadResult<Data> {\n        return this.read(cache, {\n            ...query,\n            normalizedData: { type: 'link', linkedKey: this.buildKey(query.keyParams) },\n        });\n    }\n\n    read(cache: ReadonlyCache, input: ReadInput<ReadInputExtension>): Result<Data, ReadErrors> {\n        return this.denormalize(cache, { ...input, key: input.normalizedData.linkedKey });\n    }\n\n    denormalize(cache: ReadonlyCache, input: DenormalizeInput<ReadInput<ReadInputExtension>>) {\n        const cacheEntry = cache.get<NormalizedData>(input.key, {\n            copy: false,\n        }) as CacheEntry<NormalizedData>;\n\n        if (cacheEntry) {\n            const validationResult = this.validateEntry(cacheEntry);\n            if (validationResult.isErr()) {\n                return err([...validationResult.error]);\n            }\n            const normalizedData = cacheEntry.value;\n            return this.denormalizeData(cache, { ...input, normalizedData });\n        }\n\n        return err([this.buildMissingDataError()]);\n    }\n\n    equals(x: Data, y: Data) {\n        return deepEquals(x, y);\n    }\n\n    buildMissingDataError(): MissingDataError {\n        return {\n            type: 'missingData',\n            typeName: this.typeName,\n            namespace: this.namespace,\n            data: undefined,\n        };\n    }\n}\n\n/**\n * An abstract base class that extends IdentifiableType, adding the additional constraint that the\n * only data required to write to the cache is an instance of the data itself, i.e. the identity of\n * the data lives inside the data\n */\nexport abstract class SelfIdentifiableTypeRepository<\n    Data,\n    NormalizedData,\n    KeyParams,\n    ReadInputExtension extends Record<string, any> = Record<string, unknown>,\n    WriteInputExtension extends Record<string, any> = Record<string, unknown>,\n> extends IdentifiableTypeRepository<\n    Data,\n    NormalizedData,\n    KeyParams,\n    ReadInputExtension,\n    WriteInputExtension\n> {}\n\n/**\n * An abstract base class that extends SelfIdentifiableType. Adds the constraint that the structure of\n * the key parameters must be a flat object, with no objects nested. This class provides invalidation and keybuilding 'for free'.\n * Should be preferred over IdentifiableType and SelfIdentifiableType\n */\nexport abstract class FlattenedKeySelfIdentifiableTypeRepository<\n        Data,\n        NormalizedData,\n        KeyParams extends FlattenedKeyParams,\n        ReadInputExtension extends Record<string, any> = Record<string, unknown>,\n        WriteInputExtension extends Record<string, any> = Record<string, unknown>,\n    >\n    extends SelfIdentifiableTypeRepository<\n        Data,\n        NormalizedData,\n        KeyParams,\n        ReadInputExtension,\n        WriteInputExtension\n    >\n    implements\n        Invalidatable<\n            SelfIdentifiableTypeRepository<\n                Data,\n                NormalizedData,\n                KeyParams,\n                ReadInputExtension,\n                WriteInputExtension\n            >,\n            Partial<KeyParams>\n        >\n{\n    instrumentationAttributes: InstrumentationAttributes | undefined;\n    constructor(\n        protected services: NamedCacheControllerService &\n            NamedPubSubService &\n            Partial<NamedInstrumentationService>\n    ) {\n        super(services);\n    }\n\n    abstract readonly keySchema: string[];\n\n    async invalidate(configs: Partial<KeyParams>[]): Promise<void> {\n        const startTime = this.services.instrumentation\n            ? this.services.instrumentation.currentTimeMs()\n            : 0;\n        const result = this.runInvalidate(configs).then(() => {\n            if (this.services.instrumentation) {\n                const duration = this.services.instrumentation.currentTimeMs() - startTime;\n                this.collectInstrumentation(duration);\n            }\n        });\n        return result;\n    }\n\n    protected collectInstrumentation(duration: number) {\n        if (this.services.instrumentation) {\n            const meter = this.services.instrumentation.metrics.getMeter('onestore');\n            const attributes = {\n                ...this.instrumentationAttributes,\n                namespace: this.namespace,\n                typeName: this.typeName,\n            };\n            meter\n                .createCounter<InstrumentationAttributes>(`type.invalidate.count`)\n                .add(1, attributes);\n            meter\n                .createHistogram<InstrumentationAttributes>(`type.invalidate.duration`)\n                .record(duration, attributes);\n        }\n    }\n\n    protected async runInvalidate(configs: Partial<KeyParams>[]): Promise<void> {\n        const regex = buildRegexForNamespacedKeys(\n            this.namespace,\n            this.typeName,\n            configs,\n            this.keySchema\n        );\n\n        const results: Set<Key> = new Set();\n        for await (const entry of this.services.cacheController.findAndModify(\n            { key: { $regex: regex } },\n            { type: 'invalidate' }\n        )) {\n            results.add(entry);\n        }\n        if (results.size > 0) {\n            await this.services.pubSub.publish({\n                type: 'cacheInvalidation',\n                data: results,\n            });\n        }\n    }\n\n    buildKey(config: KeyParams): Key {\n        return buildNamespacedTypeKey(this.namespace, this.typeName, config, this.keySchema);\n    }\n}\ntype ScalarKeyValue = string | number | boolean | null | undefined;\ntype FlattenedKeyParams = Record<string, ScalarKeyValue | ScalarKeyValue[]>;\nexport function buildNamespacedTypeKey(\n    namespace: string,\n    typeName: string,\n    keyConfig: FlattenedKeyParams,\n    keySchema: string[]\n): string {\n    const keyParts = keySchema\n        .map((key) => {\n            const value = keyConfig[key];\n            return `${ArrayIsArray(value) ? value.join() : value}`;\n        })\n        .join('|');\n    return `${namespace}::${typeName}(${keyParts})`;\n}\n\nexport function buildRegexForNamespacedKeys(\n    namespace: string,\n    typeName: string,\n    partialKeyConfigs: Array<FlattenedKeyParams>,\n    keySchema: string[]\n): RegExp {\n    const patterns = partialKeyConfigs.map((partial) => {\n        // Build a regex pattern for a single KeyConfig\n        const requiredParts = keySchema\n            .map((key) => {\n                if (!(key in partial)) {\n                    return `[^|]*?`; // Allow any value or absence of value (optional match)\n                }\n                const value = partial[key];\n                return `(?:${(ArrayIsArray(value) ? value.join() : String(value)).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')})`;\n            })\n            .join('\\\\|'); // Ensure properties are matched in order with literal separator\n\n        return `^${namespace}::${typeName}\\\\((?:${requiredParts})\\\\)$`;\n    });\n\n    return new RegExp(`^(?:${patterns.join('|')})$`); // Apply OR logic across separate partial configs\n}\n\nexport function extractReadWriteData<Data>(\n    result: ReadResult<Data> | WriteResult<Data>,\n    errorCollector: any[]\n): Data | undefined {\n    if (result.isOk()) {\n        return result.value;\n    }\n\n    errorCollector.push(...result.error);\n    return undefined;\n}\n\nexport function buildReadWriteResult<Data, Errors extends WriteErrors | ReadErrors>(\n    data: unknown,\n    errors: Errors\n): Result<Data, Errors> {\n    if (errors.length > 0) {\n        return err(errors);\n    }\n\n    return ok(data as Data);\n}\n\n// This type is the normalized representation of union data (either a pure union, or a discriminated union)\n// This data shape will live in the cache, and contains the discriminator (i.e. an identity of what type of data this entry represents)\n// and the normalized data for that entry\nexport type UnionRepresentation<Discriminator extends string, Data> = {\n    discriminator: Discriminator;\n    data: Data;\n};\n\n// A utility type that represents all the information required for normalizing and\n// denormalizing types into a cache, including the discriminator value, the\n// canonical representation (Data) and the normalized representation (Normalized)\nexport type DiscriminatorMap<Discriminator extends string, Data, Normalized> = {\n    [k in Discriminator]: {\n        data: Data;\n        normalized: Normalized;\n    };\n};\n\n// A utility type for inferring the union of normalized representations\n// possible based on a given DiscriminatorType\nexport type NormalizedRepresentationOf<M extends DiscriminatorMap<any, any, any>> =\n    M extends DiscriminatorMap<infer D, any, any>\n        ? { [k in D]: UnionRepresentation<k, M[k]['normalized']> }[D]\n        : never;\n\n// A utility type for inferring the discriminator -> denormalize function map\n// required by the `denormalizeUnionRepresentation` function\nexport type DenormalizeMapOf<M extends DiscriminatorMap<any, any, any>> =\n    M extends DiscriminatorMap<infer D, any, any>\n        ? { [k in D]: (normalized: M[k]['normalized']) => M[k]['data'] }\n        : never;\n\n// A utility type for inferring the canonical data type union based on\n// a DiscriminatorMap type\nexport type UnionDataOf<M extends DiscriminatorMap<any, any, any>> =\n    M extends DiscriminatorMap<any, infer D, any> ? D : never;\n\n// A utility type for inferring the discriminator string union from a\n// given discriminator map type\nexport type DiscriminatorOf<M extends DiscriminatorMap<any, any, any>> =\n    M extends DiscriminatorMap<infer D, any, any> ? D : never;\n\n// A utilty type for inferring the test/normalize map type from a\n// discriminator map type to be used in the `normalizeUnionRepresentation` function\nexport type DiscriminatorNormalizeFunctionsMap<M extends DiscriminatorMap<any, any, any>> =\n    M extends DiscriminatorMap<infer D, any, any>\n        ? {\n              [k in D]: {\n                  test: (data: M[D]['data']) => boolean;\n                  normalize: (data: M[k]['data']) => M[k]['normalized'];\n              };\n          }\n        : never;\n\n/**\n *\n * @param normalized The normalized data representation, including the discriminator value\n * @param denormalizeMap A map of discriminator -> denormalize functions to be used based on the datas discriminator\n * @returns\n */\nexport function denormalizeUnionRepresentation<\n    M extends DiscriminatorMap<string, unknown, unknown>,\n>(normalized: NormalizedRepresentationOf<M>, denormalizeMap: DenormalizeMapOf<M>): UnionDataOf<M> {\n    const discriminator = normalized.discriminator as DiscriminatorOf<M>;\n    return denormalizeMap[discriminator](normalized.data) as UnionDataOf<M>;\n}\n\n/**\n *\n * @param data The canonical/denormalized data representation\n * @param normalizeTestMap A map of discriminator to test method which return a boolean indicating if the data adheres to this \"discriminator\"\n * and a normalize function to call if the data matches this discriminator\n * @returns\n */\nexport function normalizeUnionRepresentation<M extends DiscriminatorMap<string, unknown, unknown>>(\n    data: UnionDataOf<M>,\n    normalizeTestMap: DiscriminatorNormalizeFunctionsMap<M>\n): NormalizedRepresentationOf<M> {\n    for (const discriminator of Object.keys(normalizeTestMap) as DiscriminatorOf<M>[]) {\n        const discriminatorLogic = normalizeTestMap[discriminator];\n        if (discriminatorLogic.test(data)) {\n            return {\n                discriminator,\n                data: discriminatorLogic.normalize(data),\n            } as unknown as NormalizedRepresentationOf<M>;\n        }\n    }\n\n    throw new Error('No matching union member found');\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@conduit-client/type-normalization",
+    "version": "2.0.0",
+    "private": false,
+    "description": "Luvio Normalized Cache Control Command",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/luvio-next.git",
+        "directory": "packages/@conduit-client/type-normalization"
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "exports": {
+        "./v1": {
+            "import": "./dist/v1/index.js",
+            "types": "./dist/types/v1/index.d.ts",
+            "require": "./dist/v1/index.js"
+        }
+    },
+    "main": "./dist/main/index.js",
+    "module": "./dist/main/index.js",
+    "types": "./dist/main/index.d.ts",
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build": "vite build && tsc --build --emitDeclarationOnly",
+        "clean": "rm -rf dist",
+        "test": "vitest run",
+        "test:perf": "vitest bench",
+        "test:size": "size-limit",
+        "watch": "npm run build --watch"
+    },
+    "dependencies": {
+        "@conduit-client/service-cache": "2.0.0",
+        "@conduit-client/service-cache-control": "2.0.0",
+        "@conduit-client/utils": "2.0.0"
+    },
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "size-limit": [
+        {
+            "path": "./dist/v1/index.js",
+            "limit": "2.5 kB"
+        }
+    ]
+}