@getstrata/core 0.5.42 → 0.5.43

package/dist/entries/openapi/generator.js

@@ -0,0 +1,178 @@
+// @bun
+// ../../src/config/app.ts
+var appConfig = {
+  name: "WorkHub",
+  env: process.env.APP_ENV ?? "local",
+  debug: (process.env.APP_DEBUG ?? "true") !== "false",
+  url: process.env.APP_URL ?? "http://localhost:3000",
+  apiPrefix: process.env.API_PREFIX ?? "/api/v1"
+};
+
+// ../../src/core/openapi/generator.ts
+var PUBLIC_ROUTE_DESCRIPTIONS = {
+  "GET /auth/me": "Current authenticated user",
+  "POST /auth/login": "Login with email and password",
+  "GET /auth/tokens": "List API tokens",
+  "POST /auth/tokens": "Create API token",
+  "DELETE /auth/tokens/:id": "Revoke API token",
+  "GET /users/me/export": "GDPR export of user data",
+  "DELETE /users/me": "GDPR account erasure (anonymize user, revoke tokens)",
+  "GET /organizations": "List organizations",
+  "POST /organizations": "Create organization",
+  "GET /organizations/:id/members": "List organization members",
+  "GET /projects": "List projects",
+  "POST /projects": "Create project",
+  "GET /tasks": "List tasks",
+  "POST /tasks": "Create task",
+  "GET /search": "Full-text search tasks and comments",
+  "GET /audit-logs": "List audit log entries",
+  "GET /webhooks": "List webhooks",
+  "POST /webhooks": "Create webhook",
+  "GET /reports/summary": "Cross-module summary report",
+  "GET /admin/stats": "Platform statistics",
+  "GET /admin/tenants": "List tenants",
+  "GET /admin/features": "Runtime feature flags",
+  "GET /billing/subscription": "Current tenant subscription",
+  "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"
+};
+function toOpenApiPath(path) {
+  return path.replace(/:([A-Za-z_]+)/g, "{$1}");
+}
+function requiresBearerAuth(path, method) {
+  if (path.startsWith("/auth/login") || path.startsWith("/auth/oauth")) {
+    return false;
+  }
+  if (path.startsWith("/scim/") || path.startsWith("/billing/webhooks/")) {
+    return false;
+  }
+  if (["/health", "/ready", "/metrics", "/"].includes(path)) {
+    return false;
+  }
+  if (method === "GET" && ["/organizations", "/projects", "/tasks", "/search"].some((prefix) => path.startsWith(prefix))) {
+    return false;
+  }
+  return path.startsWith("/auth/") || ["POST", "PATCH", "PUT", "DELETE"].includes(method);
+}
+function generateOpenApiSpec(routes) {
+  const paths = {};
+  for (const route of routes) {
+    const openApiPath = toOpenApiPath(route.path);
+    const method = route.method.toLowerCase();
+    const description = PUBLIC_ROUTE_DESCRIPTIONS[`${route.method} ${route.path}`] ?? `${route.method} ${route.path}`;
+    paths[openApiPath] ??= {};
+    paths[openApiPath][method] = {
+      summary: description,
+      ...requiresBearerAuth(route.path, route.method) ? { security: [{ bearerAuth: [] }] } : {},
+      responses: {
+        "200": { description: "OK" },
+        "201": { description: "Created" },
+        "204": { description: "No Content" },
+        "400": { description: "Bad Request" },
+        "401": { description: "Unauthorized" },
+        "403": { description: "Forbidden" },
+        "404": { description: "Not Found" },
+        "422": { description: "Validation Error" }
+      }
+    };
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "WorkHub API",
+      version: "1.0.0"
+    },
+    servers: [
+      { url: `${appConfig.url}${appConfig.apiPrefix}`, description: "WorkHub API" },
+      { url: appConfig.url, description: "Root (health, metrics, SCIM)" }
+    ],
+    paths,
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer"
+        }
+      },
+      schemas: {
+        ErrorResponse: {
+          type: "object",
+          properties: {
+            error: { type: "string" },
+            details: { type: "object", additionalProperties: true }
+          },
+          required: ["error"]
+        },
+        UserResource: {
+          type: "object",
+          properties: {
+            id: { type: "integer" },
+            name: { type: "string" },
+            email: { type: "string" },
+            role: { type: "string" }
+          }
+        },
+        OrganizationResource: {
+          type: "object",
+          properties: {
+            id: { type: "integer" },
+            name: { type: "string" },
+            slug: { type: "string" }
+          }
+        },
+        PaginatedMeta: {
+          type: "object",
+          properties: {
+            page: { type: "integer" },
+            per_page: { type: "integer" },
+            total: { type: "integer" },
+            last_page: { type: "integer" }
+          }
+        }
+      }
+    }
+  };
+}
+function renderOpenApiDocument(spec) {
+  return `${JSON.stringify(spec, null, 2)}
+`;
+}
+function toMethodName(method, path, apiPrefix) {
+  const relativePath = path.startsWith(apiPrefix) ? path.slice(apiPrefix.length) || "/" : path;
+  const segments = relativePath.replace(/\{|\}/g, "").split("/").filter(Boolean).flatMap((segment) => segment.split("-")).map((segment) => segment.replace(/[^a-zA-Z0-9]/g, "")).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1));
+  return `${method.toLowerCase()}${segments.join("")}`;
+}
+function toRequestPath(path, apiPrefix) {
+  return path.startsWith(apiPrefix) ? path.slice(apiPrefix.length) || "/" : path;
+}
+function renderTypeScriptSdk(spec, apiPrefix = "/api/v1") {
+  const lines = [
+    "export class WorkHubClient {",
+    `  constructor(private readonly baseUrl = "${spec.servers[0]?.url ?? ""}") {}`,
+    "",
+    "  private async request(path: string, init: RequestInit = {}): Promise<Response> {",
+    `    return await fetch(\`\${this.baseUrl}\${path}\`, init);`,
+    "  }",
+    ""
+  ];
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    const requestPath = toRequestPath(path, apiPrefix);
+    for (const method of Object.keys(methods)) {
+      const functionName = toMethodName(method, path, apiPrefix);
+      lines.push(`  async ${functionName}(init: RequestInit = {}): Promise<Response> {`, `    return await this.request("${requestPath}", { ...init, method: "${method.toUpperCase()}" });`, "  }", "");
+    }
+  }
+  lines.push("}", "");
+  return lines.join(`
+`);
+}
+export {
+  renderTypeScriptSdk,
+  renderOpenApiDocument,
+  generateOpenApiSpec
+};

package/dist/entries/openapi/validate.js

@@ -0,0 +1,28 @@
+// @bun
+// ../../src/core/openapi/validate.ts
+function validateOpenApiSpec(spec) {
+  const errors = [];
+  if (!spec.openapi.startsWith("3.")) {
+    errors.push("OpenAPI version must be 3.x.");
+  }
+  if (Object.keys(spec.paths).length === 0) {
+    errors.push("OpenAPI spec must include at least one path.");
+  }
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    if (!path.startsWith("/")) {
+      errors.push(`Path must start with '/': ${path}`);
+    }
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!("responses" in operation)) {
+        errors.push(`Operation ${method.toUpperCase()} ${path} is missing responses.`);
+      }
+    }
+  }
+  if (!spec.components.securitySchemes.bearerAuth) {
+    errors.push("Missing bearerAuth security scheme.");
+  }
+  return errors;
+}
+export {
+  validateOpenApiSpec
+};

package/dist/entries/queue/createAppQueue.js

@@ -1925,6 +1925,45 @@ class Blueprint {
     });
   }
 }
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2269,6 +2308,25 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;

package/dist/entries/queue/failedJobRepository.js

@@ -1925,6 +1925,45 @@ class Blueprint {
     });
   }
 }
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2269,6 +2308,25 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;

package/dist/entries/queue/publicQueue.js

@@ -1925,6 +1925,45 @@ class Blueprint {
     });
   }
 }
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2269,6 +2308,25 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;

package/dist/entries/queue/queueMetrics.js

@@ -1946,6 +1946,45 @@ class Blueprint {
     });
   }
 }
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2290,6 +2329,25 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;

package/dist/entries/runtime/asyncContextStore.js

@@ -0,0 +1,17 @@
+// @bun
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+export {
+  createAsyncContextStore
+};