@internetarchive/metadata-service 1.0.6 → 1.2.0-beta.0

package/src/metadata-service.ts

@@ -5,7 +5,15 @@ import {
   MetadataServiceError,
   MetadataServiceErrorType,
 } from './metadata-service-error';
-import type { MetadataServiceInterface } from './metadata-service-interface';
+import type {
+  MetadataServiceInterface,
+  MetadataWriteResult,
+} from './metadata-service-interface';
+import {
+  buildMetadataFieldPatch,
+  type MetadataFieldValue,
+  type MetadataPatchOperation,
+} from './metadata-patch';
 import { MetadataResponse } from './responses/metadata-response';
 
 /**
@@ -60,4 +68,52 @@ export class MetadataService implements MetadataServiceInterface {
 
     return { success: result.success.result };
   }
+
+  /** @inheritdoc */
+  async patchMetadata(
+    identifier: string,
+    patch: MetadataPatchOperation[],
+    target = 'metadata',
+  ): Promise<Result<MetadataWriteResult, MetadataServiceError>> {
+    if (!this.backend.writeMetadata) {
+      return {
+        error: new MetadataServiceError(
+          MetadataServiceErrorType.writeNotSupported,
+          'This metadata backend does not support writes',
+        ),
+      };
+    }
+
+    const result = await this.backend.writeMetadata(identifier, target, patch);
+    if (result.error) {
+      return result;
+    }
+
+    return { success: { changed: true, taskId: result.success?.task_id } };
+  }
+
+  /** @inheritdoc */
+  async updateMetadataField(
+    identifier: string,
+    field: string,
+    value: MetadataFieldValue,
+  ): Promise<Result<MetadataWriteResult, MetadataServiceError>> {
+    const current = await this.fetchMetadataValue<
+      Record<string, MetadataFieldValue>
+    >(identifier, 'metadata');
+    if (current.error) {
+      return { error: current.error };
+    }
+
+    const patch = buildMetadataFieldPatch(
+      field,
+      value,
+      current.success?.[field],
+    );
+    if (patch.length === 0) {
+      return { success: { changed: false } };
+    }
+
+    return this.patchMetadata(identifier, patch);
+  }
 }

package/src/responses/metadata-response.ts

@@ -5,6 +5,25 @@ import {
   SpeechMusicASREntry,
 } from '@internetarchive/iaux-item-metadata';
 
+/**
+ * A single alternate download location: a server and the directory on it that
+ * holds the item's files.
+ */
+export type AlternateLocation = {
+  server: string;
+  dir: string;
+};
+
+/**
+ * Alternate download locations for an item, beyond the primary `server`/`dir`.
+ * `servers` lists all known mirrors; `workable` is the subset currently
+ * reachable for downloads.
+ */
+export type AlternateLocations = {
+  servers: AlternateLocation[];
+  workable: AlternateLocation[];
+};
+
 /**
  * The main top-level reponse when fetching Metadata
  *
@@ -43,6 +62,16 @@ export class MetadataResponse {
 
   readonly reviews?: Review[];
 
+  readonly alternate_locations?: AlternateLocations;
+
+  readonly clips?: Record<string, unknown>;
+
+  readonly plays?: Record<string, unknown>;
+
+  readonly simplelists?: Record<string, unknown>;
+
+  readonly solo?: boolean;
+
   /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   constructor(json: Record<string, any>) {
     this.rawResponse = json;
@@ -64,5 +93,10 @@ export class MetadataResponse {
       /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
       (entry: Record<string, any>) => new Review(entry),
     );
+    this.alternate_locations = json.alternate_locations;
+    this.clips = json.clips;
+    this.plays = json.plays;
+    this.simplelists = json.simplelists;
+    this.solo = json.solo;
   }
 }

package/test/default-metadata-backend.test.ts

@@ -102,3 +102,69 @@ describe('DefaultMetadataBackend', () => {
     window.fetch = fetchBackup;
   });
 });
+
+describe('DefaultMetadataBackend writeMetadata', () => {
+  const fetchBackup = window.fetch;
+
+  afterEach(() => {
+    window.fetch = fetchBackup;
+  });
+
+  it('posts the patch as a form to the item endpoint', async () => {
+    let requestUrl = '';
+    let requestInit: RequestInit | undefined;
+    window.fetch = async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ): Promise<Response> => {
+      requestUrl = String(input);
+      requestInit = init;
+      return new Response('{ "success": true, "task_id": 7, "log": "x" }');
+    };
+
+    const backend = new DefaultMetadataBackend({ includeCredentials: true });
+    const patch = [{ op: 'replace' as const, path: '/title', value: 'New' }];
+    const result = await backend.writeMetadata('foo', 'metadata', patch);
+
+    expect(result.success?.task_id).to.equal(7);
+    expect(requestUrl).to.equal('https://archive.org/metadata/foo');
+    expect(requestInit?.method).to.equal('POST');
+    expect(requestInit?.credentials).to.equal('include');
+    const body = requestInit?.body as URLSearchParams;
+    expect(body.get('-target')).to.equal('metadata');
+    expect(JSON.parse(body.get('-patch') ?? '')).to.deep.equal(patch);
+  });
+
+  it('returns a writeError with MDAPI’s message when the write is rejected', async () => {
+    window.fetch = async (): Promise<Response> =>
+      new Response('{ "success": false, "error": "Authorization failed" }', {
+        status: 401,
+      });
+
+    const backend = new DefaultMetadataBackend();
+    const result = await backend.writeMetadata('foo', 'metadata', []);
+
+    expect(result.error?.type).to.equal(MetadataServiceErrorType.writeError);
+    expect(result.error?.message).to.equal('Authorization failed');
+  });
+
+  it('returns a writeError when MDAPI does not report success', async () => {
+    window.fetch = async (): Promise<Response> => new Response('{}');
+
+    const backend = new DefaultMetadataBackend();
+    const result = await backend.writeMetadata('foo', 'metadata', []);
+
+    expect(result.error?.type).to.equal(MetadataServiceErrorType.writeError);
+  });
+
+  it('returns a networkError when the request fails', async () => {
+    window.fetch = async (): Promise<Response> => {
+      throw new Error('offline');
+    };
+
+    const backend = new DefaultMetadataBackend();
+    const result = await backend.writeMetadata('foo', 'metadata', []);
+
+    expect(result.error?.type).to.equal(MetadataServiceErrorType.networkError);
+  });
+});

package/test/metadata-patch.test.ts

@@ -0,0 +1,53 @@
+import { expect } from '@open-wc/testing';
+import { buildMetadataFieldPatch } from '../src/metadata-patch';
+
+describe('buildMetadataFieldPatch', () => {
+  it('replaces an existing field', () => {
+    expect(buildMetadataFieldPatch('title', 'New', 'Old')).to.deep.equal([
+      { op: 'replace', path: '/title', value: 'New' },
+    ]);
+  });
+
+  it('adds a field that is absent', () => {
+    expect(buildMetadataFieldPatch('volume', ['2'], undefined)).to.deep.equal([
+      { op: 'add', path: '/volume', value: '2' },
+    ]);
+  });
+
+  it('writes a single-entry list as a bare string', () => {
+    expect(
+      buildMetadataFieldPatch('subject', ['one'], ['one', 'two']),
+    ).to.deep.equal([{ op: 'replace', path: '/subject', value: 'one' }]);
+  });
+
+  it('keeps multiple values as a list', () => {
+    expect(buildMetadataFieldPatch('subject', ['a', 'b'], 'a')).to.deep.equal([
+      { op: 'replace', path: '/subject', value: ['a', 'b'] },
+    ]);
+  });
+
+  it('removes a field set to nothing', () => {
+    expect(buildMetadataFieldPatch('notes', [], 'old')).to.deep.equal([
+      { op: 'remove', path: '/notes' },
+    ]);
+    expect(buildMetadataFieldPatch('notes', '', ['a', 'b'])).to.deep.equal([
+      { op: 'remove', path: '/notes' },
+    ]);
+  });
+
+  it('returns an empty patch when nothing changes', () => {
+    expect(buildMetadataFieldPatch('title', ['Same'], 'Same')).to.deep.equal(
+      [],
+    );
+    expect(buildMetadataFieldPatch('title', 'Same', ['Same'])).to.deep.equal(
+      [],
+    );
+    expect(buildMetadataFieldPatch('notes', [], undefined)).to.deep.equal([]);
+  });
+
+  it('escapes the key as a JSON Pointer', () => {
+    expect(buildMetadataFieldPatch('a/b~c', 'x', undefined)).to.deep.equal([
+      { op: 'add', path: '/a~1b~0c', value: 'x' },
+    ]);
+  });
+});

package/test/metadata-service-write.test.ts

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect } from '@open-wc/testing';
+
+import { Result } from '@internetarchive/result-type';
+import { MetadataBackendInterface } from '../src/backend/metadata-backend-interface';
+import { MetadataService } from '../src/metadata-service';
+import {
+  MetadataServiceError,
+  MetadataServiceErrorType,
+} from '../src/metadata-service-error';
+import type { MetadataPatchOperation } from '../src/metadata-patch';
+
+class WritableMockBackend implements MetadataBackendInterface {
+  current: Record<string, unknown> = {};
+
+  readError?: MetadataServiceError;
+
+  writeError?: MetadataServiceError;
+
+  writes: { identifier: string; target: string; patch: any[] }[] = [];
+
+  async fetchMetadata(
+    _identifier: string,
+    keypath?: string,
+  ): Promise<Result<any, MetadataServiceError>> {
+    if (this.readError) return { error: this.readError };
+    if (keypath !== 'metadata') return { success: {} };
+    return { success: { result: this.current } };
+  }
+
+  async writeMetadata(
+    identifier: string,
+    target: string,
+    patch: MetadataPatchOperation[],
+  ): Promise<Result<any, MetadataServiceError>> {
+    if (this.writeError) return { error: this.writeError };
+    this.writes.push({ identifier, target, patch });
+    return { success: { success: true, task_id: 42 } };
+  }
+}
+
+describe('MetadataService writes', () => {
+  describe('patchMetadata', () => {
+    it('sends the patch to the metadata target by default', async () => {
+      const backend = new WritableMockBackend();
+      const service = new MetadataService(backend);
+      const patch = [{ op: 'remove' as const, path: '/notes' }];
+
+      const result = await service.patchMetadata('foo', patch);
+
+      expect(result.success).to.deep.equal({ changed: true, taskId: 42 });
+      expect(backend.writes).to.deep.equal([
+        { identifier: 'foo', target: 'metadata', patch },
+      ]);
+    });
+
+    it('passes a backend error through', async () => {
+      const backend = new WritableMockBackend();
+      backend.writeError = new MetadataServiceError(
+        MetadataServiceErrorType.writeError,
+        'nope',
+      );
+      const service = new MetadataService(backend);
+
+      const result = await service.patchMetadata('foo', []);
+
+      expect(result.error?.message).to.equal('nope');
+    });
+
+    it('reports writeNotSupported for a backend without writes', async () => {
+      const readOnlyBackend: MetadataBackendInterface = {
+        fetchMetadata: async () => ({ success: {} }),
+      };
+      const service = new MetadataService(readOnlyBackend);
+
+      const result = await service.patchMetadata('foo', []);
+
+      expect(result.error?.type).to.equal(
+        MetadataServiceErrorType.writeNotSupported,
+      );
+    });
+  });
+
+  describe('updateMetadataField', () => {
+    it('replaces a field MDAPI has', async () => {
+      const backend = new WritableMockBackend();
+      backend.current = { title: 'Old' };
+      const service = new MetadataService(backend);
+
+      const result = await service.updateMetadataField('foo', 'title', 'New');
+
+      expect(result.success).to.deep.equal({ changed: true, taskId: 42 });
+      expect(backend.writes[0].patch).to.deep.equal([
+        { op: 'replace', path: '/title', value: 'New' },
+      ]);
+    });
+
+    it('adds a field MDAPI does not have', async () => {
+      const backend = new WritableMockBackend();
+      backend.current = { title: 'T' };
+      const service = new MetadataService(backend);
+
+      await service.updateMetadataField('foo', 'volume', ['2']);
+
+      expect(backend.writes[0].patch).to.deep.equal([
+        { op: 'add', path: '/volume', value: '2' },
+      ]);
+    });
+
+    it('skips the write when MDAPI already has the value', async () => {
+      const backend = new WritableMockBackend();
+      backend.current = { subject: ['a', 'b'] };
+      const service = new MetadataService(backend);
+
+      const result = await service.updateMetadataField('foo', 'subject', [
+        'a',
+        'b',
+      ]);
+
+      expect(result.success).to.deep.equal({ changed: false });
+      expect(backend.writes).to.be.empty;
+    });
+
+    it('returns the read error without writing', async () => {
+      const backend = new WritableMockBackend();
+      backend.readError = new MetadataServiceError(
+        MetadataServiceErrorType.searchEngineError,
+        "Couldn't locate item 'foo'",
+      );
+      const service = new MetadataService(backend);
+
+      const result = await service.updateMetadataField('foo', 'title', 'New');
+
+      expect(result.error?.message).to.equal("Couldn't locate item 'foo'");
+      expect(backend.writes).to.be.empty;
+    });
+  });
+});

package/test/mock-response-generator.ts

@@ -57,6 +57,17 @@ export class MockResponseGenerator {
       server: 'ia800201.us.archive.org',
       uniq: 162444403,
       workable_servers: ['ia800201.us.archive.org', 'ia600201.us.archive.org'],
+      alternate_locations: {
+        servers: [
+          { server: 'ia800201.us.archive.org', dir: '/27/items/foo' },
+          { server: 'ia600201.us.archive.org', dir: '/27/items/foo' },
+        ],
+        workable: [{ server: 'ia800201.us.archive.org', dir: '/27/items/foo' }],
+      },
+      clips: { '60|120': [1, 2, 3] },
+      plays: {},
+      simplelists: {},
+      solo: false,
     };
   }
 }

package/test/responses/metadata-response.test.ts

@@ -0,0 +1,55 @@
+import { expect } from '@open-wc/testing';
+
+import { MetadataResponse } from '../../src/responses/metadata-response';
+
+describe('MetadataResponse', () => {
+  it('parses alternate_locations into servers and workable lists', async () => {
+    const response = new MetadataResponse({
+      metadata: { identifier: 'foo' },
+      alternate_locations: {
+        servers: [
+          { server: 'ia801234.us.archive.org', dir: '/12/items/foo' },
+          { server: 'ia601234.us.archive.org', dir: '/12/items/foo' },
+        ],
+        workable: [{ server: 'ia801234.us.archive.org', dir: '/12/items/foo' }],
+      },
+    });
+    expect(response.alternate_locations?.servers).to.have.lengthOf(2);
+    expect(response.alternate_locations?.servers[0].server).to.equal(
+      'ia801234.us.archive.org',
+    );
+    expect(response.alternate_locations?.servers[0].dir).to.equal(
+      '/12/items/foo',
+    );
+    expect(response.alternate_locations?.workable).to.have.lengthOf(1);
+  });
+
+  it('exposes the clips, plays, and simplelists maps', async () => {
+    const response = new MetadataResponse({
+      metadata: { identifier: 'foo' },
+      clips: { '60|120': [1, 2, 3] },
+      plays: { total: 5 },
+      simplelists: {},
+    });
+    expect(response.clips).to.deep.equal({ '60|120': [1, 2, 3] });
+    expect(response.plays).to.deep.equal({ total: 5 });
+    expect(response.simplelists).to.deep.equal({});
+  });
+
+  it('exposes the solo flag', async () => {
+    const response = new MetadataResponse({
+      metadata: { identifier: 'foo' },
+      solo: true,
+    });
+    expect(response.solo).to.be.true;
+  });
+
+  it('leaves the top-level fields undefined when absent', async () => {
+    const response = new MetadataResponse({ metadata: { identifier: 'foo' } });
+    expect(response.alternate_locations).to.be.undefined;
+    expect(response.clips).to.be.undefined;
+    expect(response.plays).to.be.undefined;
+    expect(response.simplelists).to.be.undefined;
+    expect(response.solo).to.be.undefined;
+  });
+});

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:github.com)",
-      "Bash(gh api *)",
-      "Bash(git -C /Users/jason/Projects/IA/iaux/iaux-metadata-service status)",
-      "Bash(git -C /Users/jason/Projects/IA/iaux/iaux-metadata-service log --oneline -10)",
-      "Bash(git -C /Users/jason/Projects/IA/iaux/iaux-metadata-service remote -v)",
-      "Bash(git *)",
-      "Bash(host local.archive.org)",
-      "Bash(dig +short local.archive.org)",
-      "Bash(mkcert -CAROOT)"
-    ]
-  }
-}

package/dist/src/models/file.d.ts

@@ -1,29 +0,0 @@
-import { Byte, Duration } from '@internetarchive/field-parsers';
-/**
- * This represents an Internet Archive File
- *
- * @export
- * @class File
- */
-export declare class File {
-    readonly rawValue: Readonly<Record<string, any>>;
-    get name(): string;
-    get source(): string;
-    get btih(): string;
-    get md5(): string;
-    get format(): string;
-    get mtime(): Date | undefined;
-    get crc32(): string;
-    get sha1(): string;
-    get original(): string | undefined;
-    get size(): Byte | undefined;
-    get title(): string | undefined;
-    get length(): Duration | undefined;
-    get height(): number | undefined;
-    get width(): number | undefined;
-    get track(): number | undefined;
-    get external_identifier(): string | string[] | undefined;
-    get creator(): string | undefined;
-    get album(): string | undefined;
-    constructor(json?: Record<string, any>);
-}

package/dist/src/models/file.js

@@ -1,104 +0,0 @@
-import { __decorate } from "tslib";
-import { Memoize } from 'typescript-memoize';
-import { ByteParser, DurationParser, NumberParser, } from '@internetarchive/field-parsers';
-/**
- * This represents an Internet Archive File
- *
- * @export
- * @class File
- */
-export class File {
-    get name() {
-        return this.rawValue.name;
-    }
-    get source() {
-        return this.rawValue.source;
-    }
-    get btih() {
-        return this.rawValue.btih;
-    }
-    get md5() {
-        return this.rawValue.md5;
-    }
-    get format() {
-        return this.rawValue.format;
-    }
-    get mtime() {
-        if (this.rawValue.mtime == null) {
-            return undefined;
-        }
-        const numberValue = NumberParser.shared.parseValue(this.rawValue.mtime);
-        if (numberValue) {
-            return new Date(numberValue * 1000);
-        }
-    }
-    get crc32() {
-        return this.rawValue.crc32;
-    }
-    get sha1() {
-        return this.rawValue.sha1;
-    }
-    get original() {
-        return this.rawValue.original;
-    }
-    get size() {
-        return this.rawValue.size != null
-            ? ByteParser.shared.parseValue(this.rawValue.size)
-            : undefined;
-    }
-    get title() {
-        return this.rawValue.title;
-    }
-    get length() {
-        return this.rawValue.length != null
-            ? DurationParser.shared.parseValue(this.rawValue.length)
-            : undefined;
-    }
-    get height() {
-        return this.rawValue.height != null
-            ? NumberParser.shared.parseValue(this.rawValue.height)
-            : undefined;
-    }
-    get width() {
-        return this.rawValue.width != null
-            ? NumberParser.shared.parseValue(this.rawValue.width)
-            : undefined;
-    }
-    get track() {
-        return this.rawValue.track != null
-            ? NumberParser.shared.parseValue(this.rawValue.track)
-            : undefined;
-    }
-    get external_identifier() {
-        return this.rawValue.external_identifier;
-    }
-    get creator() {
-        return this.rawValue.creator;
-    }
-    get album() {
-        return this.rawValue.album;
-    }
-    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-    constructor(json = {}) {
-        this.rawValue = json;
-    }
-}
-__decorate([
-    Memoize()
-], File.prototype, "mtime", null);
-__decorate([
-    Memoize()
-], File.prototype, "size", null);
-__decorate([
-    Memoize()
-], File.prototype, "length", null);
-__decorate([
-    Memoize()
-], File.prototype, "height", null);
-__decorate([
-    Memoize()
-], File.prototype, "width", null);
-__decorate([
-    Memoize()
-], File.prototype, "track", null);
-//# sourceMappingURL=file.js.map

package/dist/src/models/file.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.js","sourceRoot":"","sources":["../../../src/models/file.ts"],"names":[],"mappings":"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","sourcesContent":["import { Memoize } from 'typescript-memoize';\nimport {\n  Byte,\n  ByteParser,\n  Duration,\n  DurationParser,\n  NumberParser,\n} from '@internetarchive/field-parsers';\n\n/**\n * This represents an Internet Archive File\n *\n * @export\n * @class File\n */\nexport class File {\n  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n  readonly rawValue: Readonly<Record<string, any>>;\n\n  get name(): string {\n    return this.rawValue.name;\n  }\n\n  get source(): string {\n    return this.rawValue.source;\n  }\n\n  get btih(): string {\n    return this.rawValue.btih;\n  }\n\n  get md5(): string {\n    return this.rawValue.md5;\n  }\n\n  get format(): string {\n    return this.rawValue.format;\n  }\n\n  @Memoize() get mtime(): Date | undefined {\n    if (this.rawValue.mtime == null) {\n      return undefined;\n    }\n    const numberValue = NumberParser.shared.parseValue(this.rawValue.mtime);\n    if (numberValue) {\n      return new Date(numberValue * 1000);\n    }\n  }\n\n  get crc32(): string {\n    return this.rawValue.crc32;\n  }\n\n  get sha1(): string {\n    return this.rawValue.sha1;\n  }\n\n  get original(): string | undefined {\n    return this.rawValue.original;\n  }\n\n  @Memoize() get size(): Byte | undefined {\n    return this.rawValue.size != null\n      ? ByteParser.shared.parseValue(this.rawValue.size)\n      : undefined;\n  }\n\n  get title(): string | undefined {\n    return this.rawValue.title;\n  }\n\n  @Memoize() get length(): Duration | undefined {\n    return this.rawValue.length != null\n      ? DurationParser.shared.parseValue(this.rawValue.length)\n      : undefined;\n  }\n\n  @Memoize() get height(): number | undefined {\n    return this.rawValue.height != null\n      ? NumberParser.shared.parseValue(this.rawValue.height)\n      : undefined;\n  }\n\n  @Memoize() get width(): number | undefined {\n    return this.rawValue.width != null\n      ? NumberParser.shared.parseValue(this.rawValue.width)\n      : undefined;\n  }\n\n  @Memoize() get track(): number | undefined {\n    return this.rawValue.track != null\n      ? NumberParser.shared.parseValue(this.rawValue.track)\n      : undefined;\n  }\n\n  get external_identifier(): string | string[] | undefined {\n    return this.rawValue.external_identifier;\n  }\n\n  get creator(): string | undefined {\n    return this.rawValue.creator;\n  }\n\n  get album(): string | undefined {\n    return this.rawValue.album;\n  }\n\n  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n  constructor(json: Record<string, any> = {}) {\n    this.rawValue = json;\n  }\n}\n"]}

package/dist/src/models/review.d.ts

@@ -1,11 +0,0 @@
-export declare class Review {
-    readonly rawValue: Readonly<Record<string, any>>;
-    get reviewbody(): string | undefined;
-    get reviewtitle(): string | undefined;
-    get reviewer(): string | undefined;
-    get reviewer_itemname(): string | undefined;
-    get reviewdate(): Date | undefined;
-    get createdate(): Date | undefined;
-    get stars(): number | undefined;
-    constructor(json?: Record<string, any>);
-}

package/dist/src/models/review.js

@@ -1,46 +0,0 @@
-import { __decorate } from "tslib";
-import { Memoize } from 'typescript-memoize';
-import { DateParser, NumberParser } from '@internetarchive/field-parsers';
-export class Review {
-    get reviewbody() {
-        return this.rawValue.reviewbody;
-    }
-    get reviewtitle() {
-        return this.rawValue.reviewtitle;
-    }
-    get reviewer() {
-        return this.rawValue.reviewer;
-    }
-    get reviewer_itemname() {
-        return this.rawValue.reviewer_itemname;
-    }
-    get reviewdate() {
-        return this.rawValue.reviewdate != null
-            ? DateParser.shared.parseValue(this.rawValue.reviewdate)
-            : undefined;
-    }
-    get createdate() {
-        return this.rawValue.createdate != null
-            ? DateParser.shared.parseValue(this.rawValue.createdate)
-            : undefined;
-    }
-    get stars() {
-        return this.rawValue.stars != null
-            ? NumberParser.shared.parseValue(this.rawValue.stars)
-            : undefined;
-    }
-    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-    constructor(json = {}) {
-        this.rawValue = json;
-    }
-}
-__decorate([
-    Memoize()
-], Review.prototype, "reviewdate", null);
-__decorate([
-    Memoize()
-], Review.prototype, "createdate", null);
-__decorate([
-    Memoize()
-], Review.prototype, "stars", null);
-//# sourceMappingURL=review.js.map