@lde/dataset-registry-client 0.4.0 → 0.4.3

package/README.md

@@ -1,4 +1,3 @@
 # Dataset registry Client
 
 A client for registries that contain [DCAT-AP 3.0](https://semiceu.github.io/DCAT-AP/releases/3.0.0/) dataset descriptions.
-

package/dist/client.d.ts

@@ -0,0 +1,74 @@
+import { Dataset } from '@lde/dataset';
+import { Paginator } from './paginator.js';
+export declare class Client {
+    private readonly sparqlEndpoint;
+    private readonly schema;
+    constructor(sparqlEndpoint: URL, schema?: {
+        readonly '@type': "dcat:Dataset";
+        readonly title: {
+            readonly '@id': "dcterms:title";
+            readonly '@multilang': true;
+        };
+        readonly description: {
+            readonly '@id': "dcterms:description";
+            readonly '@optional': true;
+            readonly '@multilang': true;
+        };
+        readonly language: {
+            readonly '@id': "dcterms:language";
+            readonly '@optional': true;
+            readonly '@array': true;
+        };
+        readonly license: {
+            readonly '@id': "dcterms:license";
+            readonly '@optional': true;
+        };
+        readonly creator: {
+            readonly '@id': "dcterms:creator";
+            readonly '@optional': true;
+            readonly '@array': true;
+            readonly '@schema': {
+                readonly name: {
+                    readonly '@id': "foaf:name";
+                    readonly '@multilang': true;
+                };
+            };
+        };
+        readonly publisher: {
+            readonly '@id': "dcterms:publisher";
+            readonly '@optional': true;
+            readonly '@schema': {
+                readonly name: {
+                    readonly '@id': "foaf:name";
+                    readonly '@multilang': true;
+                };
+            };
+        };
+        readonly distribution: {
+            readonly '@id': "dcat:distribution";
+            readonly '@array': true;
+            readonly '@schema': {
+                readonly '@type': "dcat:Distribution";
+                readonly accessURL: "dcat:accessURL";
+                readonly mediaType: "dcat:mediaType";
+                readonly byteSize: {
+                    readonly '@id': "dcat:byteSize";
+                    readonly '@type': "xsd:nonNegativeInteger";
+                    readonly '@optional': true;
+                };
+                readonly conformsTo: {
+                    readonly '@id': "dcterms:conformsTo";
+                    readonly '@optional': true;
+                };
+                readonly modified: {
+                    readonly '@id': "dcterms:modified";
+                    readonly '@type': "xsd:dateTime";
+                    readonly '@optional': true;
+                };
+            };
+        };
+    });
+    query(criteria: object): Promise<Paginator<Dataset>>;
+    query(constructQuery: string): Promise<Paginator<Dataset>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAgB,MAAM,cAAc,CAAC;AAIrD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,cAAc,EAAE,GAAG,EACnB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAgB;IAGlC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACpD,KAAK,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;CAoElE"}

package/dist/client.js

@@ -0,0 +1,67 @@
+import { Dataset, Distribution } from '@lde/dataset';
+import { DatasetSchema } from './schema.js';
+import { createLens } from 'ldkit';
+import { prepareQuery } from './query.js';
+import { Paginator } from './paginator.js';
+export class Client {
+    sparqlEndpoint;
+    schema;
+    constructor(sparqlEndpoint, schema = DatasetSchema) {
+        this.sparqlEndpoint = sparqlEndpoint;
+        this.schema = schema;
+    }
+    async query(args = {}) {
+        const datasets = createLens(this.schema, {
+            sources: [this.sparqlEndpoint.toString()],
+            // logQuery: (query) => console.debug(query),
+        });
+        let results;
+        let total;
+        let pageSize;
+        if (typeof args === 'string') {
+            // Custom query has no paginated results.
+            results = await datasets.query(prepareQuery(args));
+            total = results.length;
+            pageSize = total;
+        }
+        else {
+            // With search criteria the results are paginated.
+            total = await datasets.count({ ...args });
+            pageSize = 1000;
+        }
+        return new Paginator(async (offset, limit) => {
+            let items;
+            if (typeof args === 'string') {
+                // Custom query has no paginated results.
+                // TODO: we could add a convention here like {OFFSET} {LIMIT} in the query string.
+                items = await datasets.query(prepareQuery(args));
+            }
+            else {
+                items = await datasets.find({ ...args, take: limit, skip: offset });
+            }
+            return items.map((dataset) => new Dataset({
+                iri: new URL(dataset.$id),
+                title: dataset.title,
+                description: dataset.description,
+                language: dataset.language,
+                license: dataset.license ? new URL(dataset.license) : undefined,
+                distributions: dataset.distribution.map((d) => {
+                    const distribution = new Distribution(new URL(d.accessURL), d.mediaType, d.conformsTo ? new URL(d.conformsTo) : undefined);
+                    distribution.byteSize = d.byteSize ?? undefined;
+                    distribution.lastModified = d.modified ?? undefined;
+                    return distribution;
+                }),
+                creator: dataset.creator.map((creator) => ({
+                    iri: new URL(creator.$id),
+                    name: creator.name,
+                })),
+                publisher: dataset.publisher
+                    ? {
+                        iri: new URL(dataset.publisher.$id),
+                        name: dataset.publisher.name,
+                    }
+                    : undefined,
+            }));
+        }, total, pageSize);
+    }
+}

package/dist/dcat.d.ts

@@ -0,0 +1,6 @@
+export declare const dcat: import("ldkit/namespaces").NamespaceInterface<{
+    readonly iri: "http://www.w3.org/ns/dcat#";
+    readonly prefix: "dcat:";
+    readonly terms: readonly ["Dataset", "Distribution", "accessURL", "keyword", "mediaType", "byteSize", "distribution", "modified", "downloadURL"];
+}>;
+//# sourceMappingURL=dcat.d.ts.map

package/dist/dcat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dcat.d.ts","sourceRoot":"","sources":["../src/dcat.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;EAcN,CAAC"}

package/dist/dcat.js

@@ -0,0 +1,16 @@
+import { createNamespace } from 'ldkit/namespaces';
+export const dcat = createNamespace({
+    iri: 'http://www.w3.org/ns/dcat#',
+    prefix: 'dcat:',
+    terms: [
+        'Dataset',
+        'Distribution',
+        'accessURL',
+        'keyword',
+        'mediaType',
+        'byteSize',
+        'distribution',
+        'modified',
+        'downloadURL',
+    ],
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './dcat.js';
+export * from './paginator.js';
+export * from './schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './client.js';
+export * from './dcat.js';
+export * from './paginator.js';
+export * from './schema.js';

package/dist/paginator.d.ts

@@ -0,0 +1,8 @@
+export declare class Paginator<T> implements AsyncIterable<T> {
+    private readonly fetchPage;
+    readonly total: number;
+    private readonly pageSize;
+    constructor(fetchPage: (offset: number, limit: number) => Promise<T[]>, total: number, pageSize?: number);
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=paginator.d.ts.map

package/dist/paginator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../src/paginator.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAEjD,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,KAAK,EAAE,MAAM;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAFR,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,EAC3D,KAAK,EAAE,MAAM,EACZ,QAAQ,SAAO;IAG3B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgBlD"}

package/dist/paginator.js

@@ -0,0 +1,23 @@
+export class Paginator {
+    fetchPage;
+    total;
+    pageSize;
+    constructor(fetchPage, total, pageSize = 1000) {
+        this.fetchPage = fetchPage;
+        this.total = total;
+        this.pageSize = pageSize;
+    }
+    async *[Symbol.asyncIterator]() {
+        let offset = 0;
+        while (true) {
+            if (offset >= this.total) {
+                break;
+            }
+            const items = await this.fetchPage(offset, this.pageSize);
+            for (const item of items) {
+                yield item;
+            }
+            offset += items.length;
+        }
+    }
+}

package/dist/query.d.ts

@@ -0,0 +1,2 @@
+export declare function prepareQuery(query: string): string;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAMA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAelD"}

package/dist/query.js

@@ -0,0 +1,18 @@
+import { Generator, Parser } from 'sparqljs';
+import { ldkit, rdf } from 'ldkit/namespaces';
+import { DataFactory } from 'n3';
+const generator = new Generator();
+export function prepareQuery(query) {
+    const parsed = new Parser().parse(query);
+    if (parsed.type !== 'query' || 'CONSTRUCT' !== parsed.queryType) {
+        throw new Error('Must be CONSTRUCT query');
+    }
+    const template = parsed.template;
+    template.push({
+        subject: template[0].subject,
+        predicate: DataFactory.namedNode(rdf.type),
+        object: DataFactory.namedNode(ldkit.Resource),
+    });
+    parsed.template = template;
+    return generator.stringify(parsed);
+}

package/dist/schema.d.ts

@@ -0,0 +1,66 @@
+export declare const DatasetSchema: {
+    readonly '@type': "dcat:Dataset";
+    readonly title: {
+        readonly '@id': "dcterms:title";
+        readonly '@multilang': true;
+    };
+    readonly description: {
+        readonly '@id': "dcterms:description";
+        readonly '@optional': true;
+        readonly '@multilang': true;
+    };
+    readonly language: {
+        readonly '@id': "dcterms:language";
+        readonly '@optional': true;
+        readonly '@array': true;
+    };
+    readonly license: {
+        readonly '@id': "dcterms:license";
+        readonly '@optional': true;
+    };
+    readonly creator: {
+        readonly '@id': "dcterms:creator";
+        readonly '@optional': true;
+        readonly '@array': true;
+        readonly '@schema': {
+            readonly name: {
+                readonly '@id': "foaf:name";
+                readonly '@multilang': true;
+            };
+        };
+    };
+    readonly publisher: {
+        readonly '@id': "dcterms:publisher";
+        readonly '@optional': true;
+        readonly '@schema': {
+            readonly name: {
+                readonly '@id': "foaf:name";
+                readonly '@multilang': true;
+            };
+        };
+    };
+    readonly distribution: {
+        readonly '@id': "dcat:distribution";
+        readonly '@array': true;
+        readonly '@schema': {
+            readonly '@type': "dcat:Distribution";
+            readonly accessURL: "dcat:accessURL";
+            readonly mediaType: "dcat:mediaType";
+            readonly byteSize: {
+                readonly '@id': "dcat:byteSize";
+                readonly '@type': "xsd:nonNegativeInteger";
+                readonly '@optional': true;
+            };
+            readonly conformsTo: {
+                readonly '@id': "dcterms:conformsTo";
+                readonly '@optional': true;
+            };
+            readonly modified: {
+                readonly '@id': "dcterms:modified";
+                readonly '@type': "xsd:dateTime";
+                readonly '@optional': true;
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEhB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,67 @@
+import { dcterms, foaf, xsd } from 'ldkit/namespaces';
+import { dcat } from './dcat.js';
+export const DatasetSchema = {
+    '@type': dcat.Dataset,
+    title: {
+        '@id': dcterms.title,
+        '@multilang': true,
+    },
+    description: {
+        '@id': dcterms.description,
+        '@optional': true, // But required in DCAT-AP 3.0
+        '@multilang': true,
+    },
+    language: {
+        '@id': dcterms.language,
+        '@optional': true,
+        '@array': true,
+    },
+    license: {
+        '@id': dcterms.license,
+        '@optional': true,
+    },
+    creator: {
+        '@id': dcterms.creator,
+        '@optional': true, // But required in DCAT-AP 3.0
+        '@array': true,
+        '@schema': {
+            name: {
+                '@id': foaf.name,
+                '@multilang': true,
+            },
+        },
+    },
+    publisher: {
+        '@id': dcterms.publisher,
+        '@optional': true,
+        '@schema': {
+            name: {
+                '@id': foaf.name,
+                '@multilang': true,
+            },
+        },
+    },
+    distribution: {
+        '@id': dcat.distribution,
+        '@array': true,
+        '@schema': {
+            '@type': dcat.Distribution,
+            accessURL: dcat.accessURL,
+            mediaType: dcat.mediaType,
+            byteSize: {
+                '@id': dcat.byteSize,
+                '@type': xsd.nonNegativeInteger,
+                '@optional': true,
+            },
+            conformsTo: {
+                '@id': dcterms.conformsTo,
+                '@optional': true,
+            },
+            modified: {
+                '@id': dcterms.modified,
+                '@type': xsd.dateTime,
+                '@optional': true,
+            },
+        },
+    },
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@lde/dataset-registry-client",
-  "version": "0.4.0",
+  "version": "0.4.3",
+  "repository": {
+    "url": "https://github.com/ldengine/lde"
+  },
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -14,12 +14,15 @@
       "default": "./dist/index.js"
     }
   },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/dataset": "0.3.1",
+    "@lde/dataset": "0.4.1",
     "ldkit": "^2.5.1",
     "n3": "^1.26.0",
     "sparqljs": "^3.7.3",