s3 impl

CODING_STANDARDS.md

@@ -0,0 +1,112 @@
+# Coding Standards
+
+## Code Structure
+
+### No Else Blocks - Use Early Returns
+
+Always prefer early returns and guard clauses over else blocks. This reduces nesting and improves readability.
+
+**❌ Bad:**
+```typescript
+if (condition) {
+  // do something
+  return result;
+} else {
+  // do something else
+  return otherResult;
+}
+```
+
+**✅ Good:**
+```typescript
+if (condition) {
+  return result;
+}
+
+return otherResult;
+```
+
+**❌ Bad:**
+```typescript
+if (error) {
+  throw new Error('Failed');
+} else {
+  return processData();
+}
+```
+
+**✅ Good:**
+```typescript
+if (error) {
+  throw new Error('Failed');
+}
+
+return processData();
+```
+
+### Multiple Conditions
+
+For multiple conditions, stack guard clauses:
+
+**❌ Bad:**
+```typescript
+if (cas !== undefined) {
+  if (cas === 0 && existing) {
+    return false;
+  } else {
+    if (cas > 0 && (!existing || existing.modifyIndex !== cas)) {
+      return false;
+    }
+  }
+}
+```
+
+**✅ Good:**
+```typescript
+if (cas === 0 && existing) {
+  return false;
+}
+
+if (cas > 0 && (!existing || existing.modifyIndex !== cas)) {
+  return false;
+}
+```
+
+### No Unnecessary Comments
+
+Avoid conversational comments like "let's", "now we", etc. Code should be self-documenting through good naming.
+
+**❌ Bad:**
+```typescript
+// Let's check if the user exists
+const user = await findUser(id);
+
+// Now let's validate the permissions
+if (!user.hasPermission()) {
+  throw new Error();
+}
+```
+
+**✅ Good:**
+```typescript
+const user = await findUser(id);
+
+if (!user.hasPermission()) {
+  throw new UnauthorizedException();
+}
+```
+
+Comments should explain **why**, not **what**.
+
+**✅ Acceptable:**
+```typescript
+// Consul API requires plain text "true"/"false" responses, not JSON
+return success.toString();
+```
+
+## Benefits
+
+1. **Reduced Nesting**: Flatter code structure
+2. **Better Readability**: Main logic flow is clear
+3. **Easier Maintenance**: Less cognitive load
+4. **Clearer Intent**: Guard clauses make preconditions explicit