Fix up all the broken code comments (#228)

* beep boop fix everything and im faster than the AI haha

* revert mistake

Author: Ethan-Arrowood

docs/developers/applications/caching.md

@@ -86,14 +86,14 @@ class ThirdPartyAPI extends Resource {
  async get() {
   const context = this.getContext();
   let headers = new Headers();
-  if (context.replacingVersion) / this is the existing cached record
+  if (context.replacingVersion) // this is the existing cached record
    headers.set('If-Modified-Since', new Date(context.replacingVersion).toUTCString());
   let response = await fetch(`https://some-api.com/${this.getId()}`, { headers });
   let cacheInfo = response.headers.get('Cache-Control');
   let maxAge = cacheInfo?.match(/max-age=(\d)/)?.[1];
-  if (maxAge) / we can set a specific expiration time by setting context.expiresAt
-   context.expiresAt = Date.now() + maxAge * 1000; / convert from seconds to milliseconds and add to current time
-  / we can just revalidate and return the record if the origin has confirmed that it has the same version:
+  if (maxAge) // we can set a specific expiration time by setting context.expiresAt
+   context.expiresAt = Date.now() + maxAge * 1000; // convert from seconds to milliseconds and add to current time
+  // we can just revalidate and return the record if the origin has confirmed that it has the same version:
   if (response.status === 304) return context.replacingRecord;
   ...
 ```
@@ -111,7 +111,7 @@ const { MyTable } = tables;
 export class MyTableEndpoint extends MyTable {
  async post(data) {
   if (data.invalidate)
-   / use this flag as a marker
+   // use this flag as a marker
    this.invalidate();
  }
 }
@@ -126,16 +126,16 @@ We can provide more control of an active cache with subscriptions. If there is a
 ```javascript
 class ThirdPartyAPI extends Resource {
  async *subscribe() {
-      setInterval(() => { / every second retrieve more data
-   / get the next data change event from the source
+      setInterval(() => { // every second retrieve more data
+   // get the next data change event from the source
    let update = (await fetch(`https://some-api.com/latest-update`)).json();
-   const event = { / define the change event (which will update the cache)
-    type: 'put', / this would indicate that the event includes the new data value
-    id: / the primary key of the record that updated
-    value: / the new value of the record that updated
-    timestamp: / the timestamp of when the data change occurred
+   const event = { // define the change event (which will update the cache)
+    type: 'put', // this would indicate that the event includes the new data value
+    id: // the primary key of the record that updated
+    value: // the new value of the record that updated
+    timestamp: // the timestamp of when the data change occurred
    };
-   yield event; / this returns this event, notifying the cache of the change
+   yield event; // this returns this event, notifying the cache of the change
       }, 1000);
  }
  async get() {
@@ -166,7 +166,7 @@ By default, Harper will only run the subscribe method on one thread. Harper is m
 ```javascript
 class ThirdPartyAPI extends Resource {
  static subscribeOnThisThread(threadIndex) {
-  return threadIndex < 2; / run on two threads (the first two threads)
+  return threadIndex < 2; // run on two threads (the first two threads)
  }
  async *subscribe() {
   ....
@@ -219,9 +219,9 @@ When you are using a caching table, it is important to remember that any resourc
 ```javascript
 class MyCache extends tables.MyCache {
  async post(data) {
-  / if the data is not cached locally, retrieves from source:
+  // if the data is not cached locally, retrieves from source:
   await this.ensuredLoaded();
-  / now we can be sure that the data is loaded, and can access properties
+  // now we can be sure that the data is loaded, and can access properties
   this.quantity = this.quantity - data.purchases;
  }
 }
@@ -241,7 +241,7 @@ class BlogSource extends Resource {
  get() {
   const post = await (await fetch(`https://my-blog-server/${this.getId()}`).json());
 		for (let comment of post.comments) {
-			await Comment.put(comment, this); / save this comment as part of our current context and transaction
+			await Comment.put(comment, this); // save this comment as part of our current context and transaction
 		}
 		return post;
 	}

docs/developers/applications/defining-schemas.md

@@ -195,7 +195,7 @@ HNSW indexing finds the nearest neighbors to a search vector. To use this, you c
 ```javascript
 let results = Product.search({
 	sort: { attribute: 'textEmbeddings', target: searchVector },
-	limit: 5, / get the five nearest neighbors
+	limit: 5, // get the five nearest neighbors
 });
 ```
 
@@ -205,7 +205,7 @@ This can be used in combination with other conditions as well, for example:
 let results = Product.search({
 	conditions: [{ attribute: 'price', comparator: 'lt', value: 50 }],
 	sort: { attribute: 'textEmbeddings', target: searchVector },
-	limit: 5, / get the five nearest neighbors
+	limit: 5, // get the five nearest neighbors
 });
 ```
 

docs/developers/applications/index.md

@@ -86,16 +86,16 @@ This guide is going to walk you through building a basic Harper application usin
 To define custom (JavaScript) resources as endpoints, we need to create a `resources.js` module (this goes in the root of your application folder). And then endpoints can be defined with Resource classes that `export`ed. This can be done in addition to, or in lieu of the `@export`ed types in the schema.graphql. If you are exporting and extending a table you defined in the schema make sure you remove the `@export` from the schema so that don't export the original table or resource to the same endpoint/path you are exporting with a class. Resource classes have methods that correspond to standard HTTP/REST methods, like `get`, `post`, `patch`, and `put` to implement specific handling for any of these methods (for tables they all have default implementations). To do this, we get the `Dog` class from the defined tables, extend it, and export it:
 
 ```javascript
-/ resources.js:
-const { Dog } = tables; / get the Dog table from the Harper provided set of tables (in the default database)
+// resources.js:
+const { Dog } = tables; // get the Dog table from the Harper provided set of tables (in the default database)
 
 export class DogWithHumanAge extends Dog {
 	static loadAsInstance = false;
 	async get(target) {
 		const record = await super.get(target);
 		return {
-			...record, / include all properties from the record
-			humanAge: 15 + record.age * 5, / silly calculation of human age equivalent
+			...record, // include all properties from the record
+			humanAge: 15 + record.age * 5, // silly calculation of human age equivalent
 		};
 	}
 }
@@ -123,14 +123,14 @@ We use the new table's (static) `get()` method to retrieve a breed by id. Harper
 The resource methods are automatically wrapped with a transaction and will automatically commit the changes when the method finishes. This allows us to fully utilize multiple resources in our current transaction. With our own snapshot of the database for the Dog and Breed table we can then access data like this:
 
 ```javascript
-/resource.js:
-const { Dog, Breed } = tables; / get the Breed table too
+//resource.js:
+const { Dog, Breed } = tables; // get the Breed table too
 export class DogWithBreed extends Dog {
 	static loadAsInstance = false;
 	async get(target) {
-		/ get the Dog record
+		// get the Dog record
 		const record = await super.get(target);
-		/ get the Breed record
+		// get the Breed record
 		let breedDescription = await Breed.get(record.breed);
 		return {
 			...record,
@@ -168,10 +168,10 @@ export class CustomDog extends Dog {
 	async post(target, data) {
 		if (data.action === 'add-trick') {
 			const context = this.getContext();
-			/ if we want to skip the default permission checks, we can turn off checkPermissions:
+			// if we want to skip the default permission checks, we can turn off checkPermissions:
 			target.checkPermissions = false;
 			const record = this.update(target);
-			/ and do our own/custom permission check:
+			// and do our own/custom permission check:
 			if (record.owner !== context.user?.username) {
 				throw new Error('Can not update this record');
 			}
@@ -186,7 +186,7 @@ Any methods that are not defined will fall back to Harper's default authorizatio
 You can also use the `default` export to define the root path resource handler. For example:
 
 ```javascript
-/ resources.json
+// resources.json
 export default class CustomDog extends Dog {
 	...
 ```
@@ -198,14 +198,14 @@ This will allow requests to url like / to be directly resolved to this resource.
 We can also directly implement the Resource class and use it to create new data sources from scratch that can be used as endpoints. Custom resources can also be used as caching sources. Let's say that we defined a `Breed` table that was a cache of information about breeds from another source. We could implement a caching table like:
 
 ```javascript
-const { Breed } = tables; / our Breed table
+const { Breed } = tables; // our Breed table
 class BreedSource extends Resource {
-	/ define a data source
+	// define a data source
 	async get(target) {
   return (await fetch(`https://best-dog-site.com/${target}`)).json();
 	}
 }
-/ define that our breed table is a cache of data from the data source above, with a specified expiration
+// define that our breed table is a cache of data from the data source above, with a specified expiration
 Breed.sourcedFrom(BreedSource, { expiration: 3600 });
 ```
 

docs/developers/real-time.md

@@ -96,7 +96,7 @@ WebSockets are supported through the REST interface and go through the `connect(
 ```javascript
 let ws = new WebSocket('wss://server/my-resource/341');
 ws.onmessage = (event) => {
-	/ received a notification from the server
+	// received a notification from the server
 	let data = JSON.parse(event.data);
 };
 ```
@@ -106,8 +106,8 @@ By default, the resources will make a subscription to that resource, monitoring
 ```javascript
 export class Echo extends Resource {
 	async *connect(incomingMessages) {
-		for await (let message of incomingMessages) { / wait for each incoming message from the client
-			/ and send the message back to the client
+		for await (let message of incomingMessages) { // wait for each incoming message from the client
+			// and send the message back to the client
 			yield message;
 		}
 	}
@@ -121,13 +121,13 @@ export class Example extends Resource {
 		let outgoingMessages = super.connect();
 		let timer = setInterval(() => {
 			  outgoingMessages.send({greeting: 'hi again!'});
-		}, 1000);  / send a message once a second
+		}, 1000);  // send a message once a second
 		incomingMessages.on('data', (message) => {
-			/ another way of echo-ing the data back to the client
+			// another way of echo-ing the data back to the client
 			outgoingMessages.send(message);
 		});
 		outgoingMessages.on('close', () => {
-			/ make sure we end the timer once the connection is closed
+			// make sure we end the timer once the connection is closed
 			clearInterval(timer);
 		});
 		return outgoingMessages;
@@ -141,7 +141,7 @@ Server Sent Events (SSE) are also supported through the REST server interface, a
 ```javascript
 let eventSource = new EventSource('https://server/my-resource/341', { withCredentials: true });
 eventSource.onmessage = (event) => {
-	/ received a notification from the server
+	// received a notification from the server
 	let data = JSON.parse(event.data);
 };
 ```

docs/developers/replication/sharding.md

@@ -75,7 +75,7 @@ Additionally, you can specify `replicateTo` and `replicatedConfirmation` paramet
 class MyTable extends tables.MyTable {
 	put(record) {
 		const context = this.getContext();
-		context.replicateTo = 2; / or an array of node names
+		context.replicateTo = 2; // or an array of node names
 		context.replicatedConfirmation = 1;
 		return super.put(record);
 	}
@@ -132,15 +132,15 @@ Alternately you can define a custom sharding strategy based on the primary key a
 
 ```javascript
 MyTable.setResidencyById((id) => {
-	return id % 2 === 0 ? 1 : 2; / return shard number
+	return id % 2 === 0 ? 1 : 2; // return shard number
 });
 ```
 
 or
 
 ```javascript
 MyTable.setResidencyById((id) => {
-	return id % 2 === 0 ? ['node1'] : ['node2']; / return array of node hostnames
+	return id % 2 === 0 ? ['node1'] : ['node2']; // return array of node hostnames
 });
 ```
 

docs/developers/security/users-and-roles.md

@@ -100,17 +100,17 @@ Each table that a role should be given some level of CRUD permissions to must be
 
 ```json
 {
-  "table_name": { / the name of the table to define CRUD perms for
-    "read": boolean, / access to read from this table
-    "insert": boolean, / access to insert data to table
-    "update": boolean, / access to update data in table
-    "delete": boolean, / access to delete row data in table
-    "attribute_permissions": [ / permissions for specific table attributes
+  "table_name": { // the name of the table to define CRUD perms for
+    "read": boolean, // access to read from this table
+    "insert": boolean, // access to insert data to table
+    "update": boolean, // access to update data in table
+    "delete": boolean, // access to delete row data in table
+    "attribute_permissions": [ // permissions for specific table attributes
         {
-          "attribute_name": "attribute_name", / attribute to assign permissions to
-          "read": boolean, / access to read this attribute from table
-          "insert": boolean, / access to insert this attribute into the table
-          "update": boolean / access to update this attribute in the table
+          "attribute_name": "attribute_name", // attribute to assign permissions to
+          "read": boolean, // access to read this attribute from table
+          "insert": boolean, // access to insert this attribute into the table
+          "update": boolean // access to update this attribute in the table
         }
     ]
 }

docs/technical-details/reference/blob.md

@@ -34,7 +34,7 @@ export class MyEndpoint extends MyTable {
 		return {
 			status: 200,
 			headers: {},
-			body: this.data, / this.data is a blob
+			body: this.data, // this.data is a blob
 		});
 	}
 }
@@ -44,11 +44,11 @@ One of the important characteristics of blobs is they natively support asynchron
 
 ```javascript
 let blob = await createBlob(stream);
-/ at this point the blob exists, but the data is still being written to storage
+// at this point the blob exists, but the data is still being written to storage
 await MyTable.put({ id: 'my-record', data: blob });
-/ we now have written a record that references the blob
+// we now have written a record that references the blob
 let record = await MyTable.get('my-record');
-/ we now have a record that gives us access to the blob. We can asynchronously access the blob's data or stream the data, and it will be available as blob the stream is written to the blob.
+// we now have a record that gives us access to the blob. We can asynchronously access the blob's data or stream the data, and it will be available as blob the stream is written to the blob.
 let stream = record.data.stream();
 ```
 
@@ -57,9 +57,9 @@ Alternately, we can also wait for the blob to be fully written to storage before
 
 ```javascript
 let blob = await createBlob(stream);
-/ at this point the blob exists, but the data is was not been written to storage
+// at this point the blob exists, but the data is was not been written to storage
 await blob.save(MyTable);
-/ we now know the blob is fully written to storage
+// we now know the blob is fully written to storage
 await MyTable.put({ id: 'my-record', data: blob });
 ```
 
@@ -73,7 +73,7 @@ Because blobs can be streamed and referenced prior to their completion, there is
 export class MyEndpoint extends MyTable {
 	let blob = this.data;
 	blob.on('error', () => {
-		/ if this was a caching table, we may want to invalidate or delete this record:
+		// if this was a caching table, we may want to invalidate or delete this record:
   		this.invalidate();
 	});
 	async get() {
@@ -93,11 +93,11 @@ Blobs that are created from streams may not have the standard `size` property av
 ```javascript
 let record = await MyTable.get('my-record');
 let blob = record.data;
-blob.size / will be available if it was saved with a known size
-let stream blob.stream(); / start streaming the data
+blob.size // will be available if it was saved with a known size
+let stream blob.stream(); // start streaming the data
 if (blob.size === undefined) {
 	blob.on('size', (size) => {
-		/ will be called once the size is available
+		// will be called once the size is available
 	})
 }
 

docs/technical-details/reference/components/extensions.md

@@ -86,11 +86,11 @@ test-component:
 In order for an extension to be classified as a Resource Extension it must implement at least one of the `handleFile()`, `handleDirectory()`, `setupFile()`, or `setupDirectory()` methods. As a standalone extension, these methods should be named and exported directly. For example:
 
 ```js
-/ ESM
+// ESM
 export function handleFile() {}
 export function setupDirectory() {}
 
-/ or CJS
+// or CJS
 function handleDirectory() {}
 function setupFile() {}