@aidc-toolkit/app-extension 1.0.31-beta → 1.0.33-beta

package/src/gs1/prefix-manager-proxy.ts

@@ -1,42 +1,197 @@
 import type { Nullishable } from "@aidc-toolkit/core";
-import type { PrefixType } from "@aidc-toolkit/gs1";
-import { type ParameterDescriptor, Types } from "../descriptor.js";
+import {
+    type GCPLengthCache,
+    type GCPLengthData,
+    PrefixManager,
+    type PrefixType,
+    RemoteGCPLengthCache
+} from "@aidc-toolkit/gs1";
+import type { Logger } from "tslog";
+import type { AppExtension } from "../app-extension.js";
+import { type ExtendsParameterDescriptor, Multiplicities, type ParameterDescriptor, Types } from "../descriptor.js";
 import { LibProxy } from "../lib-proxy.js";
 import { proxy } from "../proxy.js";
-import type { ErrorExtends, Matrix } from "../type.js";
+import type { ErrorExtends, Matrix, MatrixResult, SingletonResult } from "../type.js";
+import { identifierParameterDescriptor, identifierTypeParameterDescriptor } from "./identifier-descriptor.js";
+import { validateIdentifierType } from "./identifier-type.js";
 
 const prefixParameterDescriptor: ParameterDescriptor = {
     name: "prefix",
     type: Types.String,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     isRequired: true
 };
 
 const prefixTypeParameterDescriptor: ParameterDescriptor = {
     name: "prefixType",
     type: Types.Number,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     isRequired: false
 };
 
 const tweakFactorParameterDescriptor: ParameterDescriptor = {
     name: "tweakFactor",
     type: Types.Number,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     isRequired: false
 };
 
+const gcpLengthIdentifierParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "gcpLengthIdentifier"
+};
+
+/**
+ * Application extension GCP length cache. Data is stored in application extension shared data.
+ */
+class AppExtensionGCPLengthCache<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends RemoteGCPLengthCache {
+    /**
+     * Logger.
+     */
+    readonly #logger: Logger<object>;
+
+    /**
+     * Constructor.
+     *
+     * @param appExtension
+     * Application extension.
+     */
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
+        super(appExtension.sharedAppDataStorage);
+
+        this.#logger = appExtension.logger;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    override get nextCheckDateTime(): Promise<Date | undefined> {
+        return super.nextCheckDateTime.then((nextCheckDateTime) => {
+            this.#logger.debug(`GS1 Company Prefix length next check date/time ${nextCheckDateTime?.toISOString()}`);
+
+            return nextCheckDateTime;
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    override get cacheDateTime(): Promise<Date | undefined> {
+        return super.cacheDateTime.then((cacheDateTime) => {
+            this.#logger.debug(`GS1 Company Prefix length cache date/time ${cacheDateTime?.toISOString()}`);
+
+            return cacheDateTime;
+        });
+    }
+
+    override get cacheData(): Promise<GCPLengthData> {
+        return super.cacheData.then((cacheData) => {
+            this.#logger.debug("GS1 Company Prefix length cache data retrieved");
+
+            return cacheData;
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    override get sourceDateTime(): Promise<Date> {
+        return super.sourceDateTime.then((sourceDateTime) => {
+            this.#logger.debug(`GS1 Company Prefix source date/time ${sourceDateTime.toISOString()}`);
+
+            return sourceDateTime;
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    override get sourceData(): Promise<GCPLengthData> {
+        return super.sourceData.then((sourceData) => {
+            this.#logger.debug("GS1 Company Prefix length source data retrieved");
+
+            return sourceData;
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    override async update(nextCheckDateTime: Date, cacheDateTime?: Date, cacheData?: GCPLengthData): Promise<void> {
+        return super.update(nextCheckDateTime, cacheDateTime, cacheData).then(() => {
+            this.#logger.trace(`GS1 Company Prefix length saved to shared data with next check date/time ${nextCheckDateTime.toISOString()}`);
+        });
+    }
+}
+
 @proxy.describeClass(false, {
-    namespace: "GS1"
+    namespace: "GS1",
+    category: "prefix"
 })
-export class PrefixManagerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export class PrefixManagerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    readonly #gcpLengthCache: GCPLengthCache;
+    
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
+        super(appExtension);
+        
+        this.#gcpLengthCache = new AppExtensionGCPLengthCache(appExtension);
+    }
+
     @proxy.describeMethod({
         type: Types.Any,
-        isMatrix: true,
+        multiplicity: Multiplicities.SingletonArray,
         parameterDescriptors: [prefixParameterDescriptor, prefixTypeParameterDescriptor, tweakFactorParameterDescriptor]
     })
     definePrefix(prefix: string, prefixType: Nullishable<PrefixType>, tweakFactor: Nullishable<number>): Matrix<unknown> {
         // Parameters will be validated by IdentifierCreatorProxy.getCreator().
         return [[prefix, prefixType, tweakFactor]];
     }
+
+    /**
+     * Load GS1 Company Prefix length data.
+     *
+     * @returns
+     * Void promise.
+     */
+    async #loadGCPLengthData(): Promise<void> {
+        return PrefixManager.loadGCPLengthData(this.#gcpLengthCache).catch((e: unknown) => {
+            // Log and swallow error.
+            this.appExtension.logger.error("Load GS1 Company Prefix length data failed", e);
+        });
+    }
+
+    @proxy.describeMethod({
+        type: Types.Number,
+        multiplicity: Multiplicities.Matrix,
+        parameterDescriptors: [identifierTypeParameterDescriptor, gcpLengthIdentifierParameterDescriptor]
+    })
+    async gcpLength(identifierType: string, matrixIdentifiers: Matrix<string>): Promise<MatrixResult<number, ThrowError, TError>> {
+        return this.#loadGCPLengthData().then(() => this.setUpMatrixResult(
+            () => validateIdentifierType(identifierType),
+            matrixIdentifiers,
+            (validatedIdentifierType, identifier) => PrefixManager.gcpLength(validatedIdentifierType, identifier)
+        ));
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        multiplicity: Multiplicities.Singleton,
+        parameterDescriptors: []
+    })
+    async gcpLengthDateTime(): Promise<SingletonResult<string, ThrowError, TError>> {
+        return this.#loadGCPLengthData().then(() =>
+            this.singletonResult(() => PrefixManager.gcpLengthDateTime().toISOString())
+        );
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        multiplicity: Multiplicities.Singleton,
+        parameterDescriptors: []
+    })
+    async gcpLengthDisclaimer(): Promise<SingletonResult<string, ThrowError, TError>> {
+        return this.#loadGCPLengthData().then(() =>
+            this.singletonResult(() => PrefixManager.gcpLengthDisclaimer())
+        );
+    }
 }

package/src/gs1/service-proxy.ts

@@ -0,0 +1,57 @@
+import { isNullish, type Nullishable } from "@aidc-toolkit/core";
+import { verifiedByGS1 } from "@aidc-toolkit/gs1";
+import { type ExtendsParameterDescriptor, Multiplicities, type ParameterDescriptor, Types } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
+import { identifierParameterDescriptor, identifierTypeParameterDescriptor } from "./identifier-descriptor.js";
+import { validateIdentifierType } from "./identifier-type.js";
+
+const hyperlinkIdentifierParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    name: "hyperlinkIdentifier"
+};
+
+const hyperlinkTextParameterDescriptor: ParameterDescriptor = {
+    name: "hyperlinkText",
+    type: Types.String,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: false
+};
+
+const hyperlinkDetailsParameterDescriptor: ParameterDescriptor = {
+    name: "hyperlinkDetails",
+    type: Types.String,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: false
+};
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    category: "service"
+})
+export class ServiceProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    @proxy.describeMethod({
+        type: Types.Any,
+        multiplicity: Multiplicities.Matrix,
+        requiresContext: true,
+        parameterDescriptors: [
+            identifierTypeParameterDescriptor,
+            hyperlinkIdentifierParameterDescriptor,
+            hyperlinkTextParameterDescriptor,
+            hyperlinkDetailsParameterDescriptor
+        ]
+    })
+    async verifiedByGS1(identifierType: string, matrixIdentifiers: Matrix<string>, text: Nullishable<string>, details: Nullishable<string>, invocationContext: Nullishable<TInvocationContext>): Promise<MatrixResult<unknown, ThrowError, TError>> {
+        if (isNullish(invocationContext)) {
+            // Application error; no localization necessary.
+            throw new Error("Invocation context not provided by application");
+        }
+
+        return this.appExtension.mapHyperlinkResults(invocationContext, this.setUpMatrixResult(() =>
+            validateIdentifierType(identifierType),
+        matrixIdentifiers, (validatedIdentifierType, identifier) =>
+            verifiedByGS1(validatedIdentifierType, identifier, text ?? undefined, details ?? undefined)
+        ));
+    }
+}

package/src/gs1/variable-measure-proxy.ts

@@ -0,0 +1,62 @@
+import { VariableMeasure } from "@aidc-toolkit/gs1";
+import { Multiplicities, type ParameterDescriptor, Types } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
+
+const rcnFormatParameterDescriptor: ParameterDescriptor = {
+    name: "rcnFormat",
+    type: Types.String,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: true
+};
+
+const rcnParameterDescriptor: ParameterDescriptor = {
+    name: "rcn",
+    type: Types.String,
+    multiplicity: Multiplicities.Array,
+    isRequired: true
+};
+
+const rcnItemReferenceParameterDescriptor: ParameterDescriptor = {
+    name: "rcnItemReference",
+    type: Types.Number,
+    multiplicity: Multiplicities.Singleton,
+    isRequired: true
+};
+
+const rcnPriceOrWeightParameterDescriptor: ParameterDescriptor = {
+    name: "rcnPriceOrWeight",
+    type: Types.Number,
+    multiplicity: Multiplicities.Matrix,
+    isRequired: true
+};
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    category: "variableMeasure"
+})
+export class VariableMeasureProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    @proxy.describeMethod({
+        type: Types.Number,
+        multiplicity: Multiplicities.Matrix,
+        parameterDescriptors: [rcnFormatParameterDescriptor, rcnParameterDescriptor]
+    })
+    parseVariableMeasureRCN(format: string, matrixRCNs: Matrix<string>): MatrixResult<number, ThrowError, TError> {
+        return this.arrayResult(matrixRCNs, (rcn) => {
+            const rcnReference = VariableMeasure.parseRCN(format, rcn);
+
+            return [rcnReference.itemReference, rcnReference.priceOrWeight];
+        });
+    }
+
+    @proxy.describeMethod({
+        type: Types.String,
+        multiplicity: Multiplicities.Matrix,
+        ignoreInfix: true,
+        parameterDescriptors: [rcnFormatParameterDescriptor, rcnItemReferenceParameterDescriptor, rcnPriceOrWeightParameterDescriptor]
+    })
+    createVariableMeasureRCN(format: string, itemReference: number, matrixPricesOrWeights: Matrix<number>): MatrixResult<string, ThrowError, TError> {
+        return this.matrixResult(matrixPricesOrWeights, priceOrWeight => VariableMeasure.createRCN(format, itemReference, priceOrWeight));
+    }
+}

package/src/index.ts

@@ -15,12 +15,17 @@
  * limitations under the License.
  */
 export * from "./locale/i18n.js";
+
 export type * from "./type.js";
+
+export type * from "./streaming.js";
 export * from "./app-extension.js";
 export * from "./lib-proxy.js";
+
 export * from "./descriptor.js";
-export * from "./app-utility-proxy.js";
+export * from "./app-helper-proxy.js";
 export * from "./utility/index.js";
 export * as GS1 from "./gs1/index.js";
+
 export * from "./generator/index.js";
 export { expandParameterDescriptor } from "./proxy.js";