Importer uses Post

Author: joepio

data-browser/src/routes/AboutRoute.tsx

@@ -43,7 +43,7 @@ export const About: React.FunctionComponent = () => {
       </p>
       <p>
         The back-end of this app is{' '}
-        <AtomicLink href='https://github.com/joepio/atomic'>
+        <AtomicLink href='https://github.com/atomicdata-dev/atomic-data-rust'>
           atomic-server
         </AtomicLink>
         , which you can think of as an open source, web-native database.
@@ -63,7 +63,7 @@ export const About: React.FunctionComponent = () => {
       <h2>Run your own server</h2>
       <p>
         The easiest way to run an{' '}
-        <AtomicLink href='https://github.com/joepio/atomic'>
+        <AtomicLink href='https://github.com/atomicdata-dev/atomic-data-rust'>
           atomic-server
         </AtomicLink>{' '}
         is by using Docker:

lib/src/client.ts

@@ -41,13 +41,18 @@ interface FetchResourceOptions {
    * fetch through that server.
    */
   from?: string;
+  method?: 'GET' | 'POST';
+  /** The body is only used combined with the `POST` method */
+  body?: ArrayBuffer | string;
 }
 
-interface HTTPResult {
+/** Contains one or more Resources */
+interface HTTPResourceResult {
   resource: Resource;
   createdResources: Resource[];
 }
 
+/** Contains a `fetch` instance, provides methods to GET and POST several types */
 export class Client {
   private __fetchOverride?: typeof fetch;
 
@@ -110,8 +115,8 @@ export class Client {
   public async fetchResourceHTTP(
     subject: string,
     opts: FetchResourceOptions = {},
-  ): Promise<HTTPResult> {
-    const { signInfo, from } = opts;
+  ): Promise<HTTPResourceResult> {
+    const { signInfo, from, body: bodyReq } = opts;
     let createdResources: Resource[] = [];
     const parser = new JSONADParser();
     let resource = new Resource(subject);
@@ -143,6 +148,8 @@ export class Client {
 
       const response = await this.fetch(url, {
         headers: requestHeaders,
+        method: bodyReq ? 'POST' : 'GET',
+        body: bodyReq,
       });
       const body = await response.text();
 
@@ -256,16 +263,30 @@ export class Client {
     return resources;
   }
 
-  /** Instructs an Atomic Server to fetch a URL and get its JSON-AD */
-  public async importJsonAdUrl(
-    /** The URL of the JSON-AD to import */
-    jsonAdUrl: string,
-    /** Importer URL. Servers tend to have one at `example.com/import` */
-    importerUrl: string,
-  ): Promise<HTTPResult> {
-    const url = new URL(importerUrl);
-    url.searchParams.set('url', jsonAdUrl);
-
-    return this.fetchResourceHTTP(url.toString());
-  }
+  // /** Instructs an Atomic Server to fetch a URL and get its JSON-AD */
+  // public async importJsonAdUrl(
+  //   /** The URL of the JSON-AD to import */
+  //   jsonAdUrl: string,
+  //   /** Importer URL. Servers tend to have one at `example.com/import` */
+  //   importerUrl: string,
+  // ): Promise<HTTPResourceResult> {
+  //   const url = new URL(importerUrl);
+  //   url.searchParams.set('url', jsonAdUrl);
+
+  //   return this.fetchResourceHTTP(url.toString());
+  // }
+
+  // /** Instructs an Atomic Server to fetch a URL and get its JSON-AD */
+  // public async importJsonAdString(
+  //   /** The JSON-AD to import */
+  //   jsonAdString: string,
+  //   /** Importer URL. Servers tend to have one at `example.com/import` */
+  //   importerUrl: string,
+  // ): Promise<HTTPResourceResult> {
+  //   const url = new URL(importerUrl);
+
+  //   return this.fetchResourceHTTP(url.toString(), {
+  //     body: jsonAdString,
+  //   });
+  // }
 }

lib/src/index.ts

@@ -35,6 +35,7 @@ export * from './class.js';
 export * from './client.js';
 export * from './commit.js';
 export * from './error.js';
+export * from './endpoints.js';
 export * from './datatypes.js';
 export * from './parse.js';
 export * from './resource.js';

lib/src/store.ts

@@ -189,6 +189,10 @@ export class Store {
       setLoading?: boolean;
       /** Do not use WebSockets, use HTTP(S) */
       noWebSocket?: boolean;
+      /** HTTP Method, defaults to GET */
+      method?: 'GET' | 'POST';
+      /** HTTP Body for POSTing */
+      body?: ArrayBuffer | string;
     } = {},
   ): Promise<Resource> {
     if (opts.setLoading) {
@@ -206,8 +210,10 @@ export class Store {
       supportsWebSockets() &&
       ws?.readyState === WebSocket.OPEN
     ) {
+      // Use WebSocket
       await fetchWebSocket(ws, subject);
     } else {
+      // Use HTTPS
       const signInfo = this.agent
         ? { agent: this.agent, serverURL: this.getServerUrl() }
         : undefined;
@@ -216,6 +222,8 @@ export class Store {
         subject,
         {
           from: opts.fromProxy ? this.getServerUrl() : undefined,
+          method: opts.method,
+          body: opts.body,
           signInfo,
         },
       );

react/src/useImporter.ts

@@ -10,6 +10,7 @@ export function useImporter(importerUrl?: string) {
   const [url, setUrl] = useState(importerUrl);
   const [success, setSuccess] = useState(false);
   const resource = useResource(url);
+  const store = useStore();
 
   // Get the error from the resource
   useEffect(() => {
@@ -29,10 +30,21 @@ export function useImporter(importerUrl?: string) {
     setUrl(parsed.toString());
   }
 
-  function importJsonAd(jsonAdString: string) {
-    const parsed = new URL(importerUrl!);
-    parsed.searchParams.set('json', jsonAdString);
-    setUrl(parsed.toString());
+  async function importJsonAd(jsonAdString: string) {
+    if (!importerUrl) {
+      throw Error('No importer URL given');
+    }
+
+    try {
+      const resp = await importJsonAdString(store, importerUrl, jsonAdString);
+
+      if (resp.error) {
+        throw resp.error;
+      }
+    } catch (e) {
+      store.notifyError(e);
+      setSuccess(false);
+    }
   }
 
   return { importJsonAd, importURL, resource, success };