@getstrata/core 0.5.99 → 0.5.101

package/dist/entries/database/relationships.js

@@ -18,32 +18,80 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -51,12 +99,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -66,23 +114,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -104,31 +162,62 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
 }
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -137,7 +226,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -147,16 +236,20 @@ function indexMorphToRelation(children, parentsByType, relation) {
 export {
   belongsTo,
   belongsToMany,
+  getByRelationKey,
   hasMany,
+  hasManyThrough,
   hasOne,
   indexBelongsToManyRelation,
   indexBelongsToRelation,
   indexHasManyRelation,
+  indexHasManyThroughRelation,
   indexHasOneRelation,
   indexMorphManyRelation,
   indexMorphOneRelation,
   indexMorphToRelation,
   morphMany,
   morphOne,
-  morphTo
+  morphTo,
+  relationMatchKey
 };

package/dist/entries/database/repositoryQuery.js

@@ -422,6 +422,241 @@ function buildDeleteByIdQuery(table, id) {
   };
 }
 
+// ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function hasOne(definition) {
+  return {
+    type: "hasOne",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
+function belongsToMany(definition) {
+  return {
+    type: "belongsToMany",
+    ...definition
+  };
+}
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
+function indexHasManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexHasOneRelation(parents, children, relation) {
+  const grouped = indexHasManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexBelongsToRelation(children, parents, relation) {
+  const parentsById = new Map;
+  for (const parent of parents) {
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
+  }
+  const result = new Map;
+  for (const child of children) {
+    const foreignKey = child[relation.foreignKey];
+    const parent = parentsById.get(relationMatchKey(foreignKey));
+    if (parent) {
+      result.set(foreignKey, parent);
+    }
+  }
+  return result;
+}
+function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
+  const relatedById = new Map;
+  for (const related of relatedRows) {
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
+  }
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
+  }
+  for (const pivot of pivotRows) {
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
+    if (!group || !related) {
+      continue;
+    }
+    group.push(related);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function morphMany(definition) {
+  return {
+    type: "morphMany",
+    ...definition
+  };
+}
+function morphOne(definition) {
+  return {
+    type: "morphOne",
+    ...definition
+  };
+}
+function morphTo(definition) {
+  return {
+    type: "morphTo",
+    ...definition
+  };
+}
+function indexMorphManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    if (child[relation.morphTypeKey] !== relation.morphType) {
+      continue;
+    }
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexMorphOneRelation(parents, children, relation) {
+  const grouped = indexMorphManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
+function indexMorphToRelation(children, parentsByType, relation) {
+  const result = new Map;
+  for (const child of children) {
+    const morphType = String(child[relation.morphTypeKey]);
+    const parents = parentsByType.get(morphType);
+    if (!parents) {
+      continue;
+    }
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
+    if (parent) {
+      result.set(child[relation.morphIdKey], parent);
+    }
+  }
+  return result;
+}
+
 // ../../src/core/database/whereBuilder.ts
 class WhereBuilder {
   nodes = [];
@@ -589,6 +824,24 @@ class RepositoryQuery {
     });
     return this;
   }
+  withHasManyThrough(as, relation, farRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasManyThrough",
+      as,
+      relation,
+      repository: farRepository,
+      options
+    });
+    return this;
+  }
+  withTrashed() {
+    this.queryOptions = { ...this.queryOptions, withTrashed: true };
+    return this;
+  }
+  onlyTrashed() {
+    this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -652,7 +905,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -661,7 +914,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -670,7 +923,16 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey])
+        }));
+        continue;
+      }
+      if (load.kind === "hasManyThrough") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyThroughForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -679,7 +941,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.parentKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.parentKey]) ?? []
         }));
         continue;
       }
@@ -688,7 +950,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.morphIdKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.morphIdKey])
         }));
         continue;
       }
@@ -696,7 +958,7 @@ class RepositoryQuery {
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
         ...row,
-        [load.as]: grouped.get(row[relation.foreignKey])
+        [load.as]: getByRelationKey(grouped, row[relation.foreignKey])
       }));
     }
     return result;

package/dist/entries/openapi/generator.js

@@ -94,10 +94,30 @@ var PUBLIC_ROUTE_DESCRIPTIONS = {
   "POST /billing/webhooks/stripe": "Stripe webhook receiver (stub)",
   "GET /scim/v2/Users": "SCIM list users",
   "POST /scim/v2/Users": "SCIM create user",
-  "GET /scim/v2/Groups": "SCIM list groups (organizations)",
   "GET /health": "Liveness probe",
   "GET /ready": "Readiness probe",
-  "GET /metrics": "Prometheus metrics"
+  "GET /metrics": "Prometheus metrics",
+  "GET /api/user": "Current authenticated HiroApp user",
+  "POST /api/login": "Login with email and password",
+  "POST /api/logout": "Log out the current cookie session",
+  "POST /api/auth/two-factor-challenge": "Complete staff two-factor login challenge",
+  "GET /api/users/me": "Current user profile",
+  "PATCH /api/users/me": "Update profile name and email",
+  "PUT /api/users/me/password": "Change password",
+  "GET /api/users/me/sessions": "List cookie browser sessions",
+  "DELETE /api/users/me/sessions/:id": "Revoke one cookie browser session",
+  "GET /api/auth/tokens": "List API tokens",
+  "POST /api/auth/tokens": "Create API token",
+  "DELETE /api/auth/tokens/:id": "Revoke API token",
+  "GET /api/applications": "List applications",
+  "POST /api/applications": "Submit an application",
+  "GET /api/positions": "List hiring positions",
+  "GET /api/departments": "List departments",
+  "GET /api/webhooks": "List hiring webhooks",
+  "POST /api/webhooks": "Create a hiring webhook",
+  "GET /api/audit-logs": "List hiring audit log entries",
+  "GET /api/billing/subscription": "Current tenant subscription",
+  "GET /scim/v2/Groups": "SCIM list groups (departments)"
 };
 function toOpenApiPath(path) {
   return path.replace(/:([A-Za-z_]+)/g, "{$1}");