@ldo/jsonld-dataset-proxy 0.0.1-alpha.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (126) hide show
  1. package/README.md +809 -0
  2. package/dist/ContextUtil.d.ts +12 -0
  3. package/dist/ContextUtil.js +70 -0
  4. package/dist/ContextUtil.js.map +1 -0
  5. package/dist/JsonldDatasetProxyBuilder.d.ts +15 -0
  6. package/dist/JsonldDatasetProxyBuilder.js +41 -0
  7. package/dist/JsonldDatasetProxyBuilder.js.map +1 -0
  8. package/dist/ProxyContext.d.ts +31 -0
  9. package/dist/ProxyContext.js +65 -0
  10. package/dist/ProxyContext.js.map +1 -0
  11. package/dist/arrayProxy/ArrayProxy.d.ts +12 -0
  12. package/dist/arrayProxy/ArrayProxy.js +3 -0
  13. package/dist/arrayProxy/ArrayProxy.js.map +1 -0
  14. package/dist/arrayProxy/arrayMethods.d.ts +17 -0
  15. package/dist/arrayProxy/arrayMethods.js +161 -0
  16. package/dist/arrayProxy/arrayMethods.js.map +1 -0
  17. package/dist/arrayProxy/createArrayHandler.d.ts +9 -0
  18. package/dist/arrayProxy/createArrayHandler.js +140 -0
  19. package/dist/arrayProxy/createArrayHandler.js.map +1 -0
  20. package/dist/arrayProxy/isArrayProxy.d.ts +2 -0
  21. package/dist/arrayProxy/isArrayProxy.js +17 -0
  22. package/dist/arrayProxy/isArrayProxy.js.map +1 -0
  23. package/dist/arrayProxy/modifyArray.d.ts +12 -0
  24. package/dist/arrayProxy/modifyArray.js +73 -0
  25. package/dist/arrayProxy/modifyArray.js.map +1 -0
  26. package/dist/graphOf.d.ts +3 -0
  27. package/dist/graphOf.js +37 -0
  28. package/dist/graphOf.js.map +1 -0
  29. package/dist/index.d.ts +32 -0
  30. package/dist/index.js +49 -0
  31. package/dist/index.js.map +1 -0
  32. package/dist/jsonldDatasetProxy.d.ts +4 -0
  33. package/dist/jsonldDatasetProxy.js +19 -0
  34. package/dist/jsonldDatasetProxy.js.map +1 -0
  35. package/dist/language/languageMapProxy.d.ts +4 -0
  36. package/dist/language/languageMapProxy.js +55 -0
  37. package/dist/language/languageMapProxy.js.map +1 -0
  38. package/dist/language/languageSet.d.ts +23 -0
  39. package/dist/language/languageSet.js +75 -0
  40. package/dist/language/languageSet.js.map +1 -0
  41. package/dist/language/languageTypes.d.ts +2 -0
  42. package/dist/language/languageTypes.js +3 -0
  43. package/dist/language/languageTypes.js.map +1 -0
  44. package/dist/language/languageUtils.d.ts +14 -0
  45. package/dist/language/languageUtils.js +73 -0
  46. package/dist/language/languageUtils.js.map +1 -0
  47. package/dist/language/languagesOf.d.ts +12 -0
  48. package/dist/language/languagesOf.js +16 -0
  49. package/dist/language/languagesOf.js.map +1 -0
  50. package/dist/setLanguagePreferences.d.ts +3 -0
  51. package/dist/setLanguagePreferences.js +9 -0
  52. package/dist/setLanguagePreferences.js.map +1 -0
  53. package/dist/subjectProxy/SubjectProxy.d.ts +14 -0
  54. package/dist/subjectProxy/SubjectProxy.js +3 -0
  55. package/dist/subjectProxy/SubjectProxy.js.map +1 -0
  56. package/dist/subjectProxy/createSubjectHandler.d.ts +6 -0
  57. package/dist/subjectProxy/createSubjectHandler.js +73 -0
  58. package/dist/subjectProxy/createSubjectHandler.js.map +1 -0
  59. package/dist/subjectProxy/deleteFromDataset.d.ts +3 -0
  60. package/dist/subjectProxy/deleteFromDataset.js +44 -0
  61. package/dist/subjectProxy/deleteFromDataset.js.map +1 -0
  62. package/dist/subjectProxy/getValueForKey.d.ts +5 -0
  63. package/dist/subjectProxy/getValueForKey.js +43 -0
  64. package/dist/subjectProxy/getValueForKey.js.map +1 -0
  65. package/dist/subjectProxy/isSubjectProxy.d.ts +4 -0
  66. package/dist/subjectProxy/isSubjectProxy.js +25 -0
  67. package/dist/subjectProxy/isSubjectProxy.js.map +1 -0
  68. package/dist/types.d.ts +9 -0
  69. package/dist/types.js +12 -0
  70. package/dist/types.js.map +1 -0
  71. package/dist/util/NodeSet.d.ts +11 -0
  72. package/dist/util/NodeSet.js +45 -0
  73. package/dist/util/NodeSet.js.map +1 -0
  74. package/dist/util/RawObject.d.ts +8 -0
  75. package/dist/util/RawObject.js +3 -0
  76. package/dist/util/RawObject.js.map +1 -0
  77. package/dist/util/addObjectToDataset.d.ts +8 -0
  78. package/dist/util/addObjectToDataset.js +83 -0
  79. package/dist/util/addObjectToDataset.js.map +1 -0
  80. package/dist/util/createInteractOptions.d.ts +6 -0
  81. package/dist/util/createInteractOptions.js +37 -0
  82. package/dist/util/createInteractOptions.js.map +1 -0
  83. package/dist/util/getNodeFromRaw.d.ts +6 -0
  84. package/dist/util/getNodeFromRaw.js +41 -0
  85. package/dist/util/getNodeFromRaw.js.map +1 -0
  86. package/dist/util/isProxy.d.ts +5 -0
  87. package/dist/util/isProxy.js +17 -0
  88. package/dist/util/isProxy.js.map +1 -0
  89. package/dist/util/nodeToJsonldRepresentation.d.ts +6 -0
  90. package/dist/util/nodeToJsonldRepresentation.js +74 -0
  91. package/dist/util/nodeToJsonldRepresentation.js.map +1 -0
  92. package/dist/write.d.ts +3 -0
  93. package/dist/write.js +9 -0
  94. package/dist/write.js.map +1 -0
  95. package/package.json +53 -0
  96. package/src/ContextUtil.ts +90 -0
  97. package/src/JsonldDatasetProxyBuilder.ts +106 -0
  98. package/src/ProxyContext.ts +110 -0
  99. package/src/arrayProxy/ArrayProxy.ts +20 -0
  100. package/src/arrayProxy/arrayMethods.ts +219 -0
  101. package/src/arrayProxy/createArrayHandler.ts +177 -0
  102. package/src/arrayProxy/isArrayProxy.ts +23 -0
  103. package/src/arrayProxy/modifyArray.ts +129 -0
  104. package/src/graphOf.ts +63 -0
  105. package/src/index.ts +37 -0
  106. package/src/jsonldDatasetProxy.ts +27 -0
  107. package/src/language/languageMapProxy.ts +75 -0
  108. package/src/language/languageSet.ts +129 -0
  109. package/src/language/languageTypes.ts +3 -0
  110. package/src/language/languageUtils.ts +159 -0
  111. package/src/language/languagesOf.ts +61 -0
  112. package/src/setLanguagePreferences.ts +14 -0
  113. package/src/subjectProxy/SubjectProxy.ts +20 -0
  114. package/src/subjectProxy/createSubjectHandler.ts +106 -0
  115. package/src/subjectProxy/deleteFromDataset.ts +44 -0
  116. package/src/subjectProxy/getValueForKey.ts +62 -0
  117. package/src/subjectProxy/isSubjectProxy.ts +30 -0
  118. package/src/types.ts +11 -0
  119. package/src/util/NodeSet.ts +47 -0
  120. package/src/util/RawObject.ts +13 -0
  121. package/src/util/addObjectToDataset.ts +141 -0
  122. package/src/util/createInteractOptions.ts +55 -0
  123. package/src/util/getNodeFromRaw.ts +45 -0
  124. package/src/util/isProxy.ts +20 -0
  125. package/src/util/nodeToJsonldRepresentation.ts +76 -0
  126. package/src/write.ts +12 -0
@@ -0,0 +1,75 @@
1
+ import type { PredicateNode, SubjectNode } from "@ldo/rdf-utils";
2
+ import { literal, quad } from "@rdfjs/data-model";
3
+ import type { ProxyContext } from "../ProxyContext";
4
+ import {
5
+ languageKeyToLiteralLanguage,
6
+ quadsToLanguageQuadMap,
7
+ languageDeleteMatch,
8
+ } from "./languageUtils";
9
+ import type { LanguageMap, LanguageSetMap } from "./languagesOf";
10
+ import LanguageSet from "./languageSet";
11
+
12
+ export function createLanguageMapProxy<
13
+ Target extends LanguageMap | LanguageSetMap,
14
+ >(
15
+ subject: SubjectNode,
16
+ predicate: PredicateNode,
17
+ proxyContext: ProxyContext,
18
+ isArray: boolean,
19
+ ): Target {
20
+ const target: Target = {} as Target;
21
+ // Function to call to update the target to represent what's in the dataset
22
+ const targetSetter = (target: Target) => {
23
+ // Clear the target
24
+ Object.keys(target).forEach((key) => delete target[key]);
25
+ // Add current language map to target
26
+ const allQuads = proxyContext.dataset.match(subject, predicate);
27
+ const languageQuadMap = quadsToLanguageQuadMap(allQuads);
28
+ Object.entries(languageQuadMap).forEach(([language, quads]) => {
29
+ const stringArray = quads.toArray().map((quad) => quad.object.value);
30
+ if (isArray) {
31
+ target[language] = new Set(stringArray);
32
+ } else {
33
+ target[language] = stringArray[0];
34
+ }
35
+ });
36
+ };
37
+
38
+ targetSetter(target);
39
+
40
+ return new Proxy<Target>(target, {
41
+ get: (target, key) => {
42
+ targetSetter(target);
43
+ if (typeof key !== "string") {
44
+ return Reflect.get(target, key);
45
+ }
46
+ if (isArray) {
47
+ return new LanguageSet(subject, predicate, key, proxyContext);
48
+ }
49
+ return Reflect.get(target, key);
50
+ },
51
+ set: (target, key, value) => {
52
+ const language = languageKeyToLiteralLanguage(key);
53
+ // Delete all quads with the language currently
54
+ if (!isArray) {
55
+ languageDeleteMatch(proxyContext.dataset, subject, predicate, language);
56
+ }
57
+ // Add the new quad for the language
58
+ proxyContext.writeGraphs.forEach((writeGraph) => {
59
+ proxyContext.dataset.add(
60
+ quad(subject, predicate, literal(value, language), writeGraph),
61
+ );
62
+ });
63
+ return Reflect.set(target, key, value);
64
+ },
65
+ deleteProperty: (target, key) => {
66
+ languageDeleteMatch(
67
+ proxyContext.dataset,
68
+ subject,
69
+ predicate,
70
+ languageKeyToLiteralLanguage(key),
71
+ );
72
+ return Reflect.deleteProperty(target, key);
73
+ },
74
+ }) as Target;
75
+ }
@@ -0,0 +1,129 @@
1
+ import { literal, quad } from "@rdfjs/data-model";
2
+ import type { PredicateNode, SubjectNode } from "@ldo/rdf-utils";
3
+ import type { Dataset, Literal } from "@rdfjs/types";
4
+ import type { LanguageKey } from "./languageTypes";
5
+ import type { LiteralObjectQuad } from "./languageUtils";
6
+ import { languageDeleteMatch, languageMatch } from "./languageUtils";
7
+ import type { ProxyContext } from "../ProxyContext";
8
+
9
+ export default class LanguageSet implements Set<string> {
10
+ private subject: SubjectNode;
11
+ private predicate: PredicateNode;
12
+ private languageKey: LanguageKey;
13
+ private proxyContext: ProxyContext;
14
+
15
+ constructor(
16
+ subject: SubjectNode,
17
+ predicate: PredicateNode,
18
+ languageKey: LanguageKey,
19
+ proxyContext: ProxyContext,
20
+ ) {
21
+ this.subject = subject;
22
+ this.predicate = predicate;
23
+ this.languageKey = languageKey;
24
+ this.proxyContext = proxyContext;
25
+ }
26
+
27
+ private matchThis(): Dataset<LiteralObjectQuad> {
28
+ return languageMatch(
29
+ this.proxyContext.dataset,
30
+ this.subject,
31
+ this.predicate,
32
+ this.languageKey,
33
+ );
34
+ }
35
+
36
+ private getLiteral(value: string): Literal {
37
+ return this.languageKey === "@none"
38
+ ? literal(value)
39
+ : literal(value, this.languageKey);
40
+ }
41
+
42
+ public get size(): number {
43
+ return this.matchThis().size;
44
+ }
45
+
46
+ add(value: string): this {
47
+ this.proxyContext.writeGraphs.forEach((graph) => {
48
+ this.proxyContext.dataset.add(
49
+ quad(
50
+ this.subject,
51
+ this.predicate,
52
+ literal(value, this.languageKey),
53
+ graph,
54
+ ),
55
+ );
56
+ });
57
+ return this;
58
+ }
59
+
60
+ clear(): void {
61
+ languageDeleteMatch(
62
+ this.proxyContext.dataset,
63
+ this.subject,
64
+ this.predicate,
65
+ this.languageKey,
66
+ );
67
+ }
68
+
69
+ delete(value: string): boolean {
70
+ const hadValue = this.has(value);
71
+ this.proxyContext.dataset.deleteMatches(
72
+ this.subject,
73
+ this.predicate,
74
+ this.getLiteral(value),
75
+ );
76
+ return hadValue;
77
+ }
78
+
79
+ forEach(
80
+ callbackfn: (value: string, value2: string, set: Set<string>) => void,
81
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
82
+ thisArg?: any,
83
+ ): void {
84
+ const quads = this.matchThis();
85
+ quads.forEach((curQuad) => {
86
+ callbackfn(curQuad.object.value, curQuad.object.value, thisArg || this);
87
+ });
88
+ }
89
+
90
+ has(item: string): boolean {
91
+ return (
92
+ this.proxyContext.dataset.match(
93
+ this.subject,
94
+ this.predicate,
95
+ this.getLiteral(item),
96
+ ).size > 0
97
+ );
98
+ }
99
+
100
+ *entries(): IterableIterator<[string, string]> {
101
+ const quads = this.matchThis();
102
+ for (const curQuad of quads) {
103
+ yield [curQuad.object.value, curQuad.object.value];
104
+ }
105
+ }
106
+
107
+ *keys(): IterableIterator<string> {
108
+ const quads = this.matchThis();
109
+ for (const curQuad of quads) {
110
+ yield curQuad.object.value;
111
+ }
112
+ }
113
+
114
+ *values(): IterableIterator<string> {
115
+ const quads = this.matchThis();
116
+ for (const curQuad of quads) {
117
+ yield curQuad.object.value;
118
+ }
119
+ }
120
+
121
+ *[Symbol.iterator](): IterableIterator<string> {
122
+ const quads = this.matchThis();
123
+ for (const curQuad of quads) {
124
+ yield curQuad.object.value;
125
+ }
126
+ }
127
+
128
+ [Symbol.toStringTag] = "LanguageSet";
129
+ }
@@ -0,0 +1,3 @@
1
+ export type LanguageOrdering = ("@none" | "@other" | string)[];
2
+
3
+ export type LanguageKey = "@none" | string;
@@ -0,0 +1,159 @@
1
+ import type { Dataset, Literal, Quad, Quad_Object } from "@rdfjs/types";
2
+ import type { ObjectNode, PredicateNode, SubjectNode } from "@ldo/rdf-utils";
3
+ import { createDataset } from "@ldo/dataset";
4
+ import type { LanguageKey, LanguageOrdering } from "./languageTypes";
5
+
6
+ /**
7
+ *
8
+ * @param dataset
9
+ * @param subject
10
+ * @param predicate
11
+ * @param languageKey
12
+ * @returns
13
+ */
14
+ export function languageMatch(
15
+ dataset: Dataset,
16
+ subject: ObjectNode,
17
+ predicate: PredicateNode,
18
+ languageKey: LanguageKey,
19
+ ): Dataset<LiteralObjectQuad> {
20
+ const literalLanguage = languageKeyToLiteralLanguage(languageKey);
21
+ return dataset.match(subject, predicate).filter((quad) => {
22
+ return (
23
+ isLanguageLiteral(quad.object) && quad.object.language === literalLanguage
24
+ );
25
+ }) as Dataset<LiteralObjectQuad>;
26
+ }
27
+
28
+ /**
29
+ *
30
+ * @param dataset
31
+ * @param subject
32
+ * @param predicate
33
+ * @param languageKey
34
+ */
35
+ export function languageDeleteMatch(
36
+ dataset: Dataset,
37
+ subject: SubjectNode,
38
+ predicate: PredicateNode,
39
+ languageKey: LanguageKey,
40
+ ): void {
41
+ const quadsToDelete = languageMatch(dataset, subject, predicate, languageKey);
42
+ quadsToDelete.forEach((quad) => {
43
+ dataset.delete(quad);
44
+ });
45
+ }
46
+
47
+ /**
48
+ * Given a node, will return true if that node is a literal that could have a
49
+ * language. This does not guarantee that it is a language literal.
50
+ * @param node the node to test
51
+ * @returns boolean
52
+ */
53
+ export function isLanguageLiteral(node: Quad_Object): node is Literal {
54
+ return (
55
+ node.termType === "Literal" &&
56
+ (node.datatype.value ===
57
+ "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" ||
58
+ node.datatype.value === "http://www.w3.org/2001/XMLSchema#string")
59
+ );
60
+ }
61
+
62
+ export interface LiteralObjectQuad extends Quad {
63
+ object: Literal;
64
+ }
65
+
66
+ export function quadsToLanguageQuadMap(
67
+ quads: Dataset,
68
+ ): Record<LanguageKey, Dataset<LiteralObjectQuad>> {
69
+ const languageQuadMap: Record<LanguageKey, Dataset<LiteralObjectQuad>> = {};
70
+ quads.forEach((quad) => {
71
+ const literal = quad.object;
72
+ if (isLanguageLiteral(literal)) {
73
+ const languageKey = literalLanguageToLanguageKey(literal.language);
74
+ if (!languageQuadMap[languageKey]) {
75
+ languageQuadMap[languageKey] =
76
+ createDataset() as Dataset<LiteralObjectQuad>;
77
+ }
78
+ languageQuadMap[languageKey].add(quad as LiteralObjectQuad);
79
+ }
80
+ });
81
+ return languageQuadMap;
82
+ }
83
+
84
+ export function filterQuadsByLanguageOrdering(
85
+ quads: Dataset,
86
+ languageOrdering: LanguageOrdering,
87
+ ): Dataset {
88
+ const languageQuadMap = quadsToLanguageQuadMap(quads);
89
+ const validLanguages = new Set(languageOrdering);
90
+ const presentLanguages = new Set(Object.keys(languageQuadMap));
91
+ for (const currentLanguageKey of languageOrdering) {
92
+ if (presentLanguages.has(currentLanguageKey)) {
93
+ return languageQuadMap[currentLanguageKey];
94
+ }
95
+ if (currentLanguageKey === "@other") {
96
+ for (const presentLang of presentLanguages) {
97
+ if (!validLanguages.has(presentLang)) {
98
+ return languageQuadMap[presentLang];
99
+ }
100
+ }
101
+ }
102
+ }
103
+ return createDataset();
104
+ }
105
+
106
+ export function getLanguageKeyForWriteOperation(
107
+ languageOrdering: LanguageOrdering,
108
+ ): LanguageKey | undefined {
109
+ return languageOrdering.find((lang) => lang !== "@other");
110
+ }
111
+
112
+ // function addToDatasetMap(
113
+ // key: string,
114
+ // value: Quad,
115
+ // map: Record<string, Dataset>
116
+ // ) {
117
+ // if (!map[key]) {
118
+ // map[key] = createDataset();
119
+ // }
120
+ // map[key].add(value);
121
+ // }
122
+
123
+ // export function filterDatasetByLanguageOrdering(
124
+ // dataset: Dataset,
125
+ // proxyContext: ProxyContext
126
+ // ): Dataset {
127
+ // // TODO: This is an O(n) task that could be reduced to O(1) if we cached some
128
+ // // of the processing
129
+ // const validLangs = new Set(proxyContext.languageOrdering);
130
+ // const sortedLangs: Record<string, Dataset> = {};
131
+ // dataset.forEach((quad) => {
132
+ // const literal = quad.object;
133
+ // if (isLangStringNode(literal)) {
134
+ // if (literal.language === "") {
135
+ // addToDatasetMap("@none", quad, sortedLangs);
136
+ // } else if (validLangs.has(literal.language)) {
137
+ // addToDatasetMap(literal.language, quad, sortedLangs);
138
+ // } else {
139
+ // addToDatasetMap("@other", quad, sortedLangs);
140
+ // }
141
+ // }
142
+ // });
143
+ // for (const language of proxyContext.languageOrdering) {
144
+ // if (sortedLangs[language]) {
145
+ // return sortedLangs[language];
146
+ // }
147
+ // }
148
+ // return createDataset();
149
+ // }
150
+
151
+ export function languageKeyToLiteralLanguage(
152
+ languageKey: string | symbol,
153
+ ): string {
154
+ return (languageKey === "@none" ? "" : languageKey) as string;
155
+ }
156
+
157
+ export function literalLanguageToLanguageKey(literalLanguage: string): string {
158
+ return literalLanguage === "" ? "@none" : literalLanguage;
159
+ }
@@ -0,0 +1,61 @@
1
+ import { namedNode } from "@rdfjs/data-model";
2
+ import { getSubjectProxyFromObject } from "../subjectProxy/isSubjectProxy";
3
+ import type { ObjectLike } from "../types";
4
+ import { _getUnderlyingNode, _proxyContext } from "../types";
5
+ import { createLanguageMapProxy } from "./languageMapProxy";
6
+
7
+ /**
8
+ * -----------------------------------------------------------------------------
9
+ * Types
10
+ * -----------------------------------------------------------------------------
11
+ */
12
+
13
+ export type LanguageMap = {
14
+ "@none"?: string;
15
+ [language: string]: string | undefined;
16
+ };
17
+
18
+ export type LanguageSetMap = {
19
+ "@none"?: LanguageSet;
20
+ [language: string]: LanguageSet | undefined;
21
+ };
22
+
23
+ export type LanguageSet = Set<string>;
24
+
25
+ export type LanguageOfConditionalReturn<
26
+ SubjectObject extends ObjectLike,
27
+ Key extends keyof SubjectObject,
28
+ > = NonNullable<SubjectObject[Key]> extends Array<unknown>
29
+ ? LanguageSetMap
30
+ : LanguageMap;
31
+
32
+ /**
33
+ * -----------------------------------------------------------------------------
34
+ * Functions
35
+ * -----------------------------------------------------------------------------
36
+ */
37
+
38
+ /**
39
+ *
40
+ * @param subject
41
+ * @param predicate
42
+ * @returns
43
+ */
44
+ export function languagesOf<
45
+ SubjectObject extends ObjectLike,
46
+ Key extends keyof SubjectObject,
47
+ >(
48
+ subjectObject: SubjectObject,
49
+ key: Key,
50
+ ): LanguageOfConditionalReturn<SubjectObject, Key> {
51
+ const proxy = getSubjectProxyFromObject(subjectObject);
52
+ const proxyContext = proxy[_proxyContext];
53
+ const subject = proxy[_getUnderlyingNode];
54
+ const predicate = namedNode(proxyContext.contextUtil.keyToIri(key as string));
55
+ return createLanguageMapProxy<LanguageMap>(
56
+ subject,
57
+ predicate,
58
+ proxyContext,
59
+ proxyContext.contextUtil.isArray(key as string),
60
+ ) as LanguageOfConditionalReturn<SubjectObject, Key>;
61
+ }
@@ -0,0 +1,14 @@
1
+ import type { LanguageOrdering } from "./language/languageTypes";
2
+ import type { InteractOptions } from "./util/createInteractOptions";
3
+ import { createInteractOptions } from "./util/createInteractOptions";
4
+
5
+ /**
6
+ * Set the default language pr
7
+ * @param graphs The graphs that should be written to
8
+ * @returns a write builder
9
+ */
10
+ export function setLanguagePreferences(
11
+ ...languageOrdering: LanguageOrdering
12
+ ): InteractOptions {
13
+ return createInteractOptions("languageOrdering", languageOrdering);
14
+ }
@@ -0,0 +1,20 @@
1
+ import type { GraphNode } from "@ldo/rdf-utils";
2
+ import type { BlankNode, Dataset, NamedNode } from "@rdfjs/types";
3
+ import type { ContextDefinition } from "jsonld";
4
+ import type { ProxyContext } from "../ProxyContext";
5
+ import type {
6
+ _getUnderlyingDataset,
7
+ _getUnderlyingNode,
8
+ _proxyContext,
9
+ _writeGraphs,
10
+ } from "../types";
11
+
12
+ export type SubjectProxy = {
13
+ "@id"?: string;
14
+ "@context": ContextDefinition;
15
+ readonly [key: string | number | symbol]: unknown;
16
+ readonly [_getUnderlyingDataset]: Dataset;
17
+ readonly [_getUnderlyingNode]: NamedNode | BlankNode;
18
+ [_proxyContext]: ProxyContext;
19
+ readonly [_writeGraphs]: GraphNode[];
20
+ };
@@ -0,0 +1,106 @@
1
+ import { namedNode, quad } from "@rdfjs/data-model";
2
+ import type { BlankNode, NamedNode } from "@rdfjs/types";
3
+ import { addObjectToDataset } from "../util/addObjectToDataset";
4
+ import { deleteValueFromDataset } from "./deleteFromDataset";
5
+ import {
6
+ _getUnderlyingDataset,
7
+ _getUnderlyingNode,
8
+ _proxyContext,
9
+ _writeGraphs,
10
+ } from "../types";
11
+ import { getValueForKey } from "./getValueForKey";
12
+ import type { ProxyContext } from "../ProxyContext";
13
+
14
+ export interface SubjectProxyTarget {
15
+ "@id": NamedNode | BlankNode;
16
+ }
17
+
18
+ export function createSubjectHandler(
19
+ initialProxyContext: ProxyContext,
20
+ ): ProxyHandler<SubjectProxyTarget> {
21
+ let proxyContext = initialProxyContext;
22
+ return {
23
+ get(target: SubjectProxyTarget, key: string | symbol) {
24
+ switch (key) {
25
+ case _getUnderlyingDataset:
26
+ return proxyContext.dataset;
27
+ case _getUnderlyingNode:
28
+ return target["@id"];
29
+ case _proxyContext:
30
+ return proxyContext;
31
+ case _writeGraphs:
32
+ return proxyContext.writeGraphs;
33
+ case "@context":
34
+ return proxyContext.contextUtil.context;
35
+ }
36
+ return getValueForKey(target, key, proxyContext);
37
+ },
38
+ getOwnPropertyDescriptor(target: SubjectProxyTarget, key: string) {
39
+ return {
40
+ value: getValueForKey(target, key, proxyContext),
41
+ writable: true,
42
+ enumerable: true,
43
+ configurable: true,
44
+ };
45
+ },
46
+ ownKeys(target) {
47
+ const subject = target["@id"];
48
+ const tripleDataset = proxyContext.dataset.match(subject);
49
+ const keys: Set<string> = new Set(["@id"]);
50
+ tripleDataset.toArray().forEach((quad) => {
51
+ keys.add(proxyContext.contextUtil.iriToKey(quad.predicate.value));
52
+ });
53
+ return Array.from(keys);
54
+ },
55
+ set: (target: SubjectProxyTarget, key, value) => {
56
+ if (key === _proxyContext) {
57
+ proxyContext = value;
58
+ return true;
59
+ }
60
+ if (key === "@id" && typeof value === "string") {
61
+ // Replace Subject Quads
62
+ const currentSubjectQuads = proxyContext.dataset
63
+ .match(target["@id"])
64
+ .toArray();
65
+ const newSubjectQuads = currentSubjectQuads.map((curQuad) =>
66
+ quad(
67
+ namedNode(value),
68
+ curQuad.predicate,
69
+ curQuad.object,
70
+ curQuad.graph,
71
+ ),
72
+ );
73
+ currentSubjectQuads.forEach((curQuad) =>
74
+ proxyContext.dataset.delete(curQuad),
75
+ );
76
+ proxyContext.dataset.addAll(newSubjectQuads);
77
+ // Replace Object Quads
78
+ const currentObjectQuads = proxyContext.dataset
79
+ .match(undefined, undefined, target["@id"])
80
+ .toArray();
81
+ const newObjectQuads = currentObjectQuads.map((curQuad) =>
82
+ quad(
83
+ curQuad.subject,
84
+ curQuad.predicate,
85
+ namedNode(value),
86
+ curQuad.graph,
87
+ ),
88
+ );
89
+ currentObjectQuads.forEach((curQuad) =>
90
+ proxyContext.dataset.delete(curQuad),
91
+ );
92
+ proxyContext.dataset.addAll(newObjectQuads);
93
+ target["@id"] = namedNode(value);
94
+ }
95
+ addObjectToDataset(
96
+ { "@id": target["@id"], [key]: value },
97
+ true,
98
+ proxyContext,
99
+ );
100
+ return true;
101
+ },
102
+ deleteProperty(target, key) {
103
+ return deleteValueFromDataset(target, key, proxyContext);
104
+ },
105
+ };
106
+ }
@@ -0,0 +1,44 @@
1
+ import { namedNode, quad } from "@rdfjs/data-model";
2
+ import type { Term } from "@rdfjs/types";
3
+ import type { SubjectProxyTarget } from "./createSubjectHandler";
4
+ import type { ProxyContext } from "../ProxyContext";
5
+
6
+ export function deleteValueFromDataset(
7
+ target: SubjectProxyTarget,
8
+ key: string | symbol,
9
+ proxyContext: ProxyContext,
10
+ ) {
11
+ const nodesToRemove: Term[] = [];
12
+ if (key === "@context") {
13
+ return true;
14
+ }
15
+ if (key === "toString" || key === Symbol.toStringTag) {
16
+ return true;
17
+ }
18
+ if (typeof key === "symbol") {
19
+ return true;
20
+ }
21
+ const subject = target["@id"];
22
+ const predicate = namedNode(proxyContext.contextUtil.keyToIri(key));
23
+ if (key === "@id") {
24
+ nodesToRemove.push(target["@id"]);
25
+ } else {
26
+ const objectDataset = proxyContext.dataset.match(subject, predicate);
27
+ if (objectDataset.size === 0) {
28
+ return true;
29
+ } else {
30
+ nodesToRemove.push(...objectDataset.toArray().map((quad) => quad.object));
31
+ }
32
+ }
33
+ nodesToRemove.forEach((term) => {
34
+ if (term.termType === "Literal") {
35
+ proxyContext.dataset.delete(quad(subject, predicate, term));
36
+ return true;
37
+ } else if (term.termType === "NamedNode") {
38
+ proxyContext.dataset.deleteMatches(term, undefined, undefined);
39
+ proxyContext.dataset.deleteMatches(undefined, undefined, term);
40
+ return true;
41
+ }
42
+ });
43
+ return true;
44
+ }
@@ -0,0 +1,62 @@
1
+ import type { SubjectProxyTarget } from "./createSubjectHandler";
2
+ import { namedNode } from "@rdfjs/data-model";
3
+ import { nodeToJsonldRepresentation } from "../util/nodeToJsonldRepresentation";
4
+ import type { SubjectProxy } from "./SubjectProxy";
5
+ import type { ArrayProxy } from "../arrayProxy/ArrayProxy";
6
+ import type { ProxyContext } from "../ProxyContext";
7
+ import { filterQuadsByLanguageOrdering } from "../language/languageUtils";
8
+
9
+ /**
10
+ * Given a subject target and a key return the correct value
11
+ */
12
+ export function getValueForKey(
13
+ target: SubjectProxyTarget,
14
+ key: string | symbol,
15
+ proxyContext: ProxyContext,
16
+ ): SubjectProxy | ArrayProxy | string | number | boolean | undefined {
17
+ const { contextUtil, dataset } = proxyContext;
18
+ if (key === "@id") {
19
+ if (target["@id"].termType === "BlankNode") {
20
+ return undefined;
21
+ }
22
+ return contextUtil.iriToKey(target["@id"].value);
23
+ }
24
+ if (key === "toString" || key === Symbol.toStringTag) {
25
+ // TODO: this toString method right now returns [object Object],
26
+ // which is correct, but it could be more descriptive, especially
27
+ // because console.log doesn't return anyting helpful due to the proxy.
28
+ return Reflect.get(target, "toString");
29
+ }
30
+ if (typeof key === "symbol") {
31
+ return;
32
+ }
33
+ const subject = target["@id"];
34
+ const predicate = namedNode(contextUtil.keyToIri(key));
35
+ if (contextUtil.isArray(key)) {
36
+ const arrayProxy = proxyContext.createArrayProxy(
37
+ [subject, predicate, null, null],
38
+ false,
39
+ undefined,
40
+ contextUtil.isLangString(key),
41
+ );
42
+ return arrayProxy;
43
+ }
44
+ let objectDataset = dataset.match(subject, predicate);
45
+ if (contextUtil.isLangString(key)) {
46
+ objectDataset = filterQuadsByLanguageOrdering(
47
+ objectDataset,
48
+ proxyContext.languageOrdering,
49
+ );
50
+ }
51
+ if (objectDataset.size === 0) {
52
+ return undefined;
53
+ } else if (objectDataset.size === 1) {
54
+ const thing = nodeToJsonldRepresentation(
55
+ objectDataset.toArray()[0].object,
56
+ proxyContext,
57
+ );
58
+ return thing;
59
+ } else {
60
+ return proxyContext.createArrayProxy([subject, predicate, null, null]);
61
+ }
62
+ }