@internetarchive/metadata-service 0.1.1 → 1.0.0

package/index.ts

@@ -1,32 +1,6 @@
-export { Metadata } from './src/models/metadata';
-export { File } from './src/models/file';
-export { Review } from './src/models/review';
-export { SpeechMusicASREntry } from './src/models/speech-music-asr-entry';
-
-export { DateField } from './src/models/metadata-fields/field-types/date';
-
-export { NumberField } from './src/models/metadata-fields/field-types/number';
-
-export { StringField } from './src/models/metadata-fields/field-types/string';
-
-export { BooleanField } from './src/models/metadata-fields/field-types/boolean';
-
-export { ByteField } from './src/models/metadata-fields/field-types/byte';
-
-export { DurationField } from './src/models/metadata-fields/field-types/duration';
-
-export { PageProgressionField } from './src/models/metadata-fields/field-types/page-progression';
-
-export { MediaTypeField } from './src/models/metadata-fields/field-types/mediatype';
-
-export {
-  MetadataFieldInterface,
-  MetadataField,
-} from './src/models/metadata-fields/metadata-field';
-
 export { MetadataResponse } from './src/responses/metadata-response';
 
 export { DefaultMetadataBackend } from './src/backend/default-metadata-backend';
-export { MetadataServiceInterface } from './src/metadata-service-interface';
 export { MetadataService } from './src/metadata-service';
 export { MetadataServiceError } from './src/metadata-service-error';
+export { MetadataServiceInterface } from './src/metadata-service-interface';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@internetarchive/metadata-service",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "A service for fetching metadata about items in the Internet Archive",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
@@ -14,10 +14,10 @@
     "tsc:watch": "tsc --watch",
     "docs": "typedoc ./index.ts",
     "prepare": "tsc",
-    "lint:eslint": "eslint --ext .ts,.html . --ignore-path .gitignore",
-    "format:eslint": "eslint --ext .ts,.html . --fix --ignore-path .gitignore",
-    "lint:prettier": "prettier \"**/*.js\" \"**/*.ts\" --check --ignore-path .gitignore",
-    "format:prettier": "prettier \"**/*.js\" \"**/*.ts\" --write --ignore-path .gitignore",
+    "lint:eslint": "eslint .",
+    "format:eslint": "eslint . --fix",
+    "lint:prettier": "prettier \"**/*.js\" \"**/*.ts\" --check",
+    "format:prettier": "prettier \"**/*.js\" \"**/*.ts\" --write",
     "lint": "npm run lint:eslint && npm run lint:prettier",
     "format": "npm run format:eslint && npm run format:prettier",
     "circular": "madge --circular --extensions ts .",
@@ -25,26 +25,31 @@
     "test:watch": "web-test-runner --watch",
     "codecov": "npx codecov"
   },
+  "dependencies": {
+    "@internetarchive/iaux-item-metadata": "^1.0.1",
+    "@internetarchive/result-type": "^0.0.1"
+  },
   "devDependencies": {
-    "@open-wc/eslint-config": "^4.2.0",
-    "@open-wc/testing": "^2.0.0",
-    "@types/node": "13.11.1",
-    "@typescript-eslint/eslint-plugin": "^4.16.1",
-    "@typescript-eslint/parser": "^4.16.1",
-    "@web/dev-server": "^0.0.12",
-    "@web/test-runner": "^0.13.23",
+    "@open-wc/eslint-config": "^12.0.3",
+    "@open-wc/testing": "^4.0.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.10.6",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "@web/dev-server": "^0.4.6",
+    "@web/test-runner": "^0.19.0",
     "concurrently": "^5.1.0",
-    "eslint": "^7.21.0",
-    "eslint-config-prettier": "^6.11.0",
-    "husky": "^1.0.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "husky": "^9.1.7",
     "lint-staged": "^10.0.0",
     "lit-element": "^2.4.0",
     "lit-html": "^1.3.0",
-    "madge": "^3.12.0",
-    "prettier": "^2.0.4",
-    "tslib": "^1.14.1",
-    "typedoc": "^0.20.29",
-    "typescript": "^4.2.2"
+    "madge": "^8.0.0",
+    "prettier": "^3.4.2",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.27.6",
+    "typescript": "^5.7.3"
   },
   "eslintConfig": {
     "extends": [
@@ -67,11 +72,5 @@
       "prettier --write",
       "git add"
     ]
-  },
-  "dependencies": {
-    "@internetarchive/field-parsers": "^0.1.3",
-    "@internetarchive/result-type": "^0.0.1",
-    "decorator-cache-getter": "^1.0.0",
-    "typescript-memoize": "^1.1.0"
   }
 }

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

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { Result } from '@internetarchive/result-type';
-import { MetadataBackendInterface } from './metadata-backend-interface';
 import {
   MetadataServiceError,
   MetadataServiceErrorType,
 } from '../metadata-service-error';
+import { MetadataBackendInterface } from './metadata-backend-interface';
 
 /**
  * The DefaultSearchBackend performs a `window.fetch` request to archive.org
@@ -49,7 +49,7 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
   /** @inheritdoc */
   async fetchMetadata(
     identifier: string,
-    keypath?: string
+    keypath?: string,
   ): Promise<Result<any, MetadataServiceError>> {
     const path = keypath ? `/${keypath}` : '';
     const url = `https://${this.baseUrl}/metadata/${identifier}${path}`;
@@ -71,7 +71,7 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
     url: string,
     options?: {
       requestOptions?: RequestInit;
-    }
+    },
   ): Promise<Result<any, MetadataServiceError>> {
     const finalUrl = new URL(url);
     if (this.requestScope) {
@@ -90,11 +90,11 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
         err instanceof Error
           ? err.message
           : typeof err === 'string'
-          ? err
-          : 'Unknown error';
+            ? err
+            : 'Unknown error';
       return this.getErrorResult(
         MetadataServiceErrorType.networkError,
-        message
+        message,
       );
     }
 
@@ -109,7 +109,7 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
         return this.getErrorResult(
           MetadataServiceErrorType.searchEngineError,
           error,
-          forensics
+          forensics,
         );
       } else {
         // success
@@ -120,11 +120,11 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
         err instanceof Error
           ? err.message
           : typeof err === 'string'
-          ? err
-          : 'Unknown error';
+            ? err
+            : 'Unknown error';
       return this.getErrorResult(
         MetadataServiceErrorType.decodingError,
-        message
+        message,
       );
     }
   }
@@ -132,7 +132,7 @@ export class DefaultMetadataBackend implements MetadataBackendInterface {
   private getErrorResult(
     errorType: MetadataServiceErrorType,
     message?: string,
-    details?: any
+    details?: any,
   ): Result<any, MetadataServiceError> {
     const error = new MetadataServiceError(errorType, message, details);
     const result = { error };

package/src/backend/metadata-backend-interface.ts

@@ -20,6 +20,6 @@ export interface MetadataBackendInterface {
    */
   fetchMetadata(
     identifier: string,
-    keypath?: string
+    keypath?: string,
   ): Promise<Result<any, MetadataServiceError>>;
 }

package/src/metadata-service-error.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export enum MetadataServiceErrorType {
   networkError = 'MetadataService.NetworkError',
   itemNotFound = 'MetadataService.ItemNotFound',
@@ -10,8 +8,10 @@ export enum MetadataServiceErrorType {
 export class MetadataServiceError extends Error {
   type: MetadataServiceErrorType;
 
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   details?: any;
 
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   constructor(type: MetadataServiceErrorType, message?: string, details?: any) {
     super(message);
     this.name = type;

package/src/metadata-service-interface.ts

@@ -1,6 +1,6 @@
-import type { MetadataResponse } from './responses/metadata-response';
 import type { Result } from '@internetarchive/result-type';
 import type { MetadataServiceError } from './metadata-service-error';
+import type { MetadataResponse } from './responses/metadata-response';
 
 export interface MetadataServiceInterface {
   /**
@@ -10,7 +10,7 @@ export interface MetadataServiceInterface {
    * @returns {Promise<Result<MetadataResponse, MetadataServiceError>>}
    */
   fetchMetadata(
-    identifier: string
+    identifier: string,
   ): Promise<Result<MetadataResponse, MetadataServiceError>>;
 
   /**
@@ -46,6 +46,6 @@ export interface MetadataServiceInterface {
    */
   fetchMetadataValue<T>(
     identifier: string,
-    keypath: string
+    keypath: string,
   ): Promise<Result<T, MetadataServiceError>>;
 }

package/src/metadata-service.ts

@@ -1,12 +1,12 @@
-import { MetadataResponse } from './responses/metadata-response';
+import type { Result } from '@internetarchive/result-type';
+import { DefaultMetadataBackend } from './backend/default-metadata-backend';
+import { MetadataBackendInterface } from './backend/metadata-backend-interface';
 import {
   MetadataServiceError,
   MetadataServiceErrorType,
 } from './metadata-service-error';
 import type { MetadataServiceInterface } from './metadata-service-interface';
-import type { Result } from '@internetarchive/result-type';
-import { DefaultMetadataBackend } from './backend/default-metadata-backend';
-import { MetadataBackendInterface } from './backend/metadata-backend-interface';
+import { MetadataResponse } from './responses/metadata-response';
 
 /**
  * The Metadata Service is responsible for taking the raw response provided by
@@ -14,7 +14,7 @@ import { MetadataBackendInterface } from './backend/metadata-backend-interface';
  */
 export class MetadataService implements MetadataServiceInterface {
   public static default: MetadataServiceInterface = new MetadataService(
-    new DefaultMetadataBackend()
+    new DefaultMetadataBackend(),
   );
 
   private backend: MetadataBackendInterface;
@@ -25,7 +25,7 @@ export class MetadataService implements MetadataServiceInterface {
 
   /** @inheritdoc */
   async fetchMetadata(
-    identifier: string
+    identifier: string,
   ): Promise<Result<MetadataResponse, MetadataServiceError>> {
     const rawResponse = await this.backend.fetchMetadata(identifier);
     if (rawResponse.error) {
@@ -45,7 +45,7 @@ export class MetadataService implements MetadataServiceInterface {
   /** @inheritdoc */
   async fetchMetadataValue<T>(
     identifier: string,
-    keypath: string
+    keypath: string,
   ): Promise<Result<T, MetadataServiceError>> {
     const result = await this.backend.fetchMetadata(identifier, keypath);
     if (result.error) {

package/src/responses/metadata-response.ts

@@ -1,8 +1,9 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { File } from '../models/file';
-import { Metadata } from '../models/metadata';
-import { Review } from '../models/review';
-import { SpeechMusicASREntry } from '../models/speech-music-asr-entry';
+import {
+  File,
+  Metadata,
+  Review,
+  SpeechMusicASREntry,
+} from '@internetarchive/iaux-item-metadata';
 
 /**
  * The main top-level reponse when fetching Metadata
@@ -11,43 +12,46 @@ import { SpeechMusicASREntry } from '../models/speech-music-asr-entry';
  * @class MetadataResponse
  */
 export class MetadataResponse {
-  rawResponse: any;
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  readonly rawResponse: Readonly<Record<string, any>>;
 
-  created: number;
+  readonly created: number;
 
-  d1: string;
+  readonly d1: string;
 
-  d2: string;
+  readonly d2: string;
 
-  dir: string;
+  readonly dir: string;
 
-  files: File[];
+  readonly files: File[];
 
-  files_count: number;
+  readonly files_count: number;
 
-  item_last_updated: number;
+  readonly item_last_updated: number;
 
-  item_size: number;
+  readonly item_size: number;
 
-  metadata: Metadata;
+  readonly metadata: Metadata;
 
-  server: string;
+  readonly server: string;
 
-  uniq: number;
+  readonly uniq: number;
 
-  workable_servers: string[];
+  readonly workable_servers: string[];
 
-  speech_vs_music_asr?: SpeechMusicASREntry[];
+  readonly speech_vs_music_asr?: SpeechMusicASREntry[];
 
-  reviews?: Review[];
+  readonly reviews?: Review[];
 
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   constructor(json: Record<string, any>) {
     this.rawResponse = json;
     this.created = json.created;
     this.d1 = json.d1;
     this.d2 = json.d2;
     this.dir = json.dir;
-    this.files = json.files?.map((file: any) => new File(file));
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    this.files = json.files?.map((file: Record<string, any>) => new File(file));
     this.files_count = json.files_count;
     this.item_last_updated = json.item_last_updated;
     this.item_size = json.item_size;
@@ -56,6 +60,9 @@ export class MetadataResponse {
     this.uniq = json.uniq;
     this.workable_servers = json.workable_servers;
     this.speech_vs_music_asr = json.speech_vs_music_asr;
-    this.reviews = json.reviews?.map((entry: any) => new Review(entry));
+    this.reviews = json.reviews?.map(
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      (entry: Record<string, any>) => new Review(entry),
+    );
   }
 }

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

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { expect } from '@open-wc/testing';
 import { DefaultMetadataBackend } from '../src/backend/default-metadata-backend';
 import { MetadataServiceErrorType } from '../src/metadata-service-error';
@@ -62,8 +62,11 @@ describe('DefaultMetadataBackend', () => {
   it('appends the scope if provided', async () => {
     const fetchBackup = window.fetch;
     let urlCalled = '';
-    window.fetch = (url: RequestInfo): Promise<Response> => {
-      urlCalled = url.toString();
+    window.fetch = (
+      input: RequestInfo | URL,
+      init?: RequestInit | undefined,
+    ): Promise<Response> => {
+      urlCalled = input.toString();
       const response = new Response('boop');
       return new Promise(resolve => resolve(response));
     };
@@ -78,14 +81,14 @@ describe('DefaultMetadataBackend', () => {
 
   it('does not credentials for metadata endpoint', async () => {
     const fetchBackup = window.fetch;
-    let urlCalled: RequestInfo;
+    let urlCalled: RequestInfo | URL;
     let urlConfig: RequestInit | undefined;
     window.fetch = (
-      url: RequestInfo,
-      config?: RequestInit
+      input: RequestInfo | URL,
+      init?: RequestInit | undefined,
     ): Promise<Response> => {
-      urlCalled = url;
-      urlConfig = config;
+      urlCalled = input;
+      urlConfig = init;
       const response = new Response('boop');
       return new Promise(resolve => resolve(response));
     };

package/test/metadata-service.test.ts

@@ -2,21 +2,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { expect } from '@open-wc/testing';
 
-import { MockResponseGenerator } from './mock-response-generator';
-import { MetadataResponse } from '../src/responses/metadata-response';
 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 { MetadataService } from '../src/metadata-service';
+import { MetadataResponse } from '../src/responses/metadata-response';
+import { MockResponseGenerator } from './mock-response-generator';
 
 describe('MetadataService', () => {
   it('can request metadata when requested', async () => {
     class MockMetadataBackend implements MetadataBackendInterface {
       async fetchMetadata(
-        identifier: string
+        identifier: string,
       ): Promise<Result<MetadataResponse, MetadataServiceError>> {
         const responseGenerator = new MockResponseGenerator();
         const mockResponse =
@@ -36,7 +36,7 @@ describe('MetadataService', () => {
       response: any;
       async fetchMetadata(
         identifier: string,
-        keypath?: string
+        keypath?: string,
       ): Promise<Result<any, MetadataServiceError>> {
         return {
           success: {
@@ -55,7 +55,7 @@ describe('MetadataService', () => {
 
       let result = await service.fetchMetadataValue<typeof expectedResult>(
         'foo',
-        'metadata'
+        'metadata',
       );
       expect(result.success).to.equal(expectedResult);
 
@@ -64,7 +64,7 @@ describe('MetadataService', () => {
 
       result = await service.fetchMetadataValue<typeof expectedResult>(
         'foo',
-        'metadata'
+        'metadata',
       );
       expect(result.success).to.equal(expectedResult);
       expect(result.success.foo).to.equal('bar');
@@ -74,7 +74,7 @@ describe('MetadataService', () => {
   it('returns an error result if the item is not found', async () => {
     class MockSearchBackend implements MetadataBackendInterface {
       async fetchMetadata(
-        identifier: string
+        identifier: string,
       ): Promise<Result<MetadataResponse, MetadataServiceError>> {
         // this is unfortunate.. instead of getting an http 404 error,
         // we get an empty JSON object when an item is not found
@@ -91,18 +91,18 @@ describe('MetadataService', () => {
     const valueResult = await service.fetchMetadataValue('foo', 'metadata');
     expect(valueResult.error).to.not.equal(undefined);
     expect(valueResult.error?.type).to.equal(
-      MetadataServiceErrorType.itemNotFound
+      MetadataServiceErrorType.itemNotFound,
     );
   });
 
   it('returns the network error if one occurs', async () => {
     class MockSearchBackend implements MetadataBackendInterface {
       async fetchMetadata(
-        identifier: string
+        identifier: string,
       ): Promise<Result<MetadataResponse, MetadataServiceError>> {
         const error = new MetadataServiceError(
           MetadataServiceErrorType.networkError,
-          'network error'
+          'network error',
         );
         return { error };
       }
@@ -113,14 +113,14 @@ describe('MetadataService', () => {
     const metadataResult = await service.fetchMetadata('foo');
     expect(metadataResult.error).to.not.equal(undefined);
     expect(metadataResult.error?.type).to.equal(
-      MetadataServiceErrorType.networkError
+      MetadataServiceErrorType.networkError,
     );
     expect(metadataResult.error?.message).to.equal('network error');
 
     const metadataValueResult = await service.fetchMetadataValue('foo', 'bar');
     expect(metadataValueResult.error).to.not.equal(undefined);
     expect(metadataValueResult.error?.type).to.equal(
-      MetadataServiceErrorType.networkError
+      MetadataServiceErrorType.networkError,
     );
     expect(metadataValueResult.error?.message).to.equal('network error');
   });
@@ -128,11 +128,11 @@ describe('MetadataService', () => {
   it('returns a decoding error if one occurs', async () => {
     class MockSearchBackend implements MetadataBackendInterface {
       async fetchMetadata(
-        identifier: string
+        identifier: string,
       ): Promise<Result<MetadataResponse, MetadataServiceError>> {
         const error = new MetadataServiceError(
           MetadataServiceErrorType.decodingError,
-          'decoding error'
+          'decoding error',
         );
         return { error };
       }
@@ -143,7 +143,7 @@ describe('MetadataService', () => {
     const metadataResult = await service.fetchMetadata('foo');
     expect(metadataResult.error).to.not.equal(undefined);
     expect(metadataResult.error?.type).to.equal(
-      MetadataServiceErrorType.decodingError
+      MetadataServiceErrorType.decodingError,
     );
     expect(metadataResult.error?.message).to.equal('decoding error');
   });

package/.eslintrc.js

@@ -1,14 +0,0 @@
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'html'],
-  extends: ['plugin:@typescript-eslint/recommended'],
-  settings: {
-    'import/resolver': {
-      node: {
-        extensions: ['.js', '.jsx', '.ts', '.tsx'],
-        moduleDirectory: ['node_modules', 'src', 'demo'],
-      },
-    },
-  },
-};

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 {
-    rawValue: Record<string, any>;
-    get name(): string;
-    get source(): string;
-    get btih(): string;
-    get md5(): string;
-    get format(): string;
-    get mtime(): string;
-    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>);
-}