@contractspec/example.analytics-dashboard 1.57.0 → 1.58.0

package/dist/browser/query/index.js

@@ -0,0 +1,159 @@
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+
+// src/query/query.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var QueryModel = defineSchemaModel({
+  name: "QueryModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var QueryResultModel = defineSchemaModel({
+  name: "QueryResultModel",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    columns: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    rowCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    executionTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var CreateQueryInputModel = defineSchemaModel({
+  name: "CreateQueryInput",
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metricIds: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+var ExecuteQueryInputModel = defineSchemaModel({
+  name: "ExecuteQueryInput",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    parameters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    dateRange: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    filters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+
+// src/query/query.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+var OWNERS = ["@example.analytics-dashboard"];
+var CreateQueryContract = defineCommand({
+  meta: {
+    key: "analytics.query.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "create"],
+    description: "Create a data query.",
+    goal: "Define reusable data queries.",
+    context: "Query builder."
+  },
+  io: { input: CreateQueryInputModel, output: QueryModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "analytics.query.created",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["analytics", "query", "created"],
+        when: "Query created",
+        payload: QueryModel
+      }
+    ],
+    audit: ["analytics.query.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-query-happy-path",
+        given: ["User is authenticated"],
+        when: ["User submits valid query definition"],
+        then: ["Query is created", "QueryCreated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-sql-query",
+        input: {
+          name: "Monthly Revenue",
+          sql: "SELECT SUM(amount) FROM orders WHERE date >= :startDate"
+        },
+        output: { id: "query-123", name: "Monthly Revenue", type: "sql" }
+      }
+    ]
+  }
+});
+var ExecuteQueryContract = defineQuery({
+  meta: {
+    key: "analytics.query.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "execute"],
+    description: "Execute a data query.",
+    goal: "Fetch data for visualizations.",
+    context: "Dashboard rendering."
+  },
+  io: { input: ExecuteQueryInputModel, output: QueryResultModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "execute-query-happy-path",
+        given: ["Query exists"],
+        when: ["User executes query with parameters"],
+        then: ["Query results are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "execute-with-params",
+        input: { queryId: "query-123", params: { startDate: "2025-01-01" } },
+        output: { columns: ["total"], rows: [{ total: 50000 }], rowCount: 1 }
+      }
+    ]
+  }
+});
+export {
+  QueryTypeEnum,
+  QueryResultModel,
+  QueryModel,
+  ExecuteQueryInputModel,
+  ExecuteQueryContract,
+  CreateQueryInputModel,
+  CreateQueryContract
+};

package/dist/browser/query/query.enum.js

@@ -0,0 +1,11 @@
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+export {
+  QueryTypeEnum
+};

package/dist/browser/query/query.operation.js

@@ -0,0 +1,154 @@
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+
+// src/query/query.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var QueryModel = defineSchemaModel({
+  name: "QueryModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var QueryResultModel = defineSchemaModel({
+  name: "QueryResultModel",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    columns: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    rowCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    executionTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var CreateQueryInputModel = defineSchemaModel({
+  name: "CreateQueryInput",
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metricIds: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+var ExecuteQueryInputModel = defineSchemaModel({
+  name: "ExecuteQueryInput",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    parameters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    dateRange: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    filters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+
+// src/query/query.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+var OWNERS = ["@example.analytics-dashboard"];
+var CreateQueryContract = defineCommand({
+  meta: {
+    key: "analytics.query.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "create"],
+    description: "Create a data query.",
+    goal: "Define reusable data queries.",
+    context: "Query builder."
+  },
+  io: { input: CreateQueryInputModel, output: QueryModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "analytics.query.created",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["analytics", "query", "created"],
+        when: "Query created",
+        payload: QueryModel
+      }
+    ],
+    audit: ["analytics.query.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-query-happy-path",
+        given: ["User is authenticated"],
+        when: ["User submits valid query definition"],
+        then: ["Query is created", "QueryCreated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-sql-query",
+        input: {
+          name: "Monthly Revenue",
+          sql: "SELECT SUM(amount) FROM orders WHERE date >= :startDate"
+        },
+        output: { id: "query-123", name: "Monthly Revenue", type: "sql" }
+      }
+    ]
+  }
+});
+var ExecuteQueryContract = defineQuery({
+  meta: {
+    key: "analytics.query.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["analytics", "query", "execute"],
+    description: "Execute a data query.",
+    goal: "Fetch data for visualizations.",
+    context: "Dashboard rendering."
+  },
+  io: { input: ExecuteQueryInputModel, output: QueryResultModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "execute-query-happy-path",
+        given: ["Query exists"],
+        when: ["User executes query with parameters"],
+        then: ["Query results are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "execute-with-params",
+        input: { queryId: "query-123", params: { startDate: "2025-01-01" } },
+        output: { columns: ["total"], rows: [{ total: 50000 }], rowCount: 1 }
+      }
+    ]
+  }
+});
+export {
+  ExecuteQueryContract,
+  CreateQueryContract
+};

package/dist/browser/query/query.presentation.js

@@ -0,0 +1,119 @@
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+
+// src/query/query.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var QueryModel = defineSchemaModel({
+  name: "QueryModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var QueryResultModel = defineSchemaModel({
+  name: "QueryResultModel",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    columns: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    rowCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    executionTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var CreateQueryInputModel = defineSchemaModel({
+  name: "CreateQueryInput",
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metricIds: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+var ExecuteQueryInputModel = defineSchemaModel({
+  name: "ExecuteQueryInput",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    parameters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    dateRange: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    filters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+
+// src/query/query.presentation.ts
+import { definePresentation, StabilityEnum } from "@contractspec/lib.contracts";
+var QueriesListPresentation = definePresentation({
+  meta: {
+    key: "analytics.query.list",
+    version: "1.0.0",
+    title: "Queries List",
+    description: "List of saved queries",
+    domain: "analytics",
+    owners: ["@analytics-dashboard"],
+    tags: ["analytics", "queries", "list"],
+    stability: StabilityEnum.Experimental,
+    goal: "Browse and manage saved data queries.",
+    context: "The library of reusable data definitions."
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "QueriesList",
+    props: QueryModel
+  },
+  targets: ["react", "markdown"],
+  policy: {
+    flags: ["analytics.queries.enabled"]
+  }
+});
+var QueryBuilderPresentation = definePresentation({
+  meta: {
+    key: "analytics.query.builder",
+    version: "1.0.0",
+    title: "Query Builder",
+    description: "Visual query builder interface",
+    domain: "analytics",
+    owners: ["@analytics-dashboard"],
+    tags: ["analytics", "query", "builder"],
+    stability: StabilityEnum.Experimental,
+    goal: "Visually construct data queries and transformations.",
+    context: "Developer tool for data analysis."
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "QueryBuilder",
+    props: QueryModel
+  },
+  targets: ["react"],
+  policy: {
+    flags: ["analytics.queries.enabled"]
+  }
+});
+export {
+  QueryBuilderPresentation,
+  QueriesListPresentation
+};

package/dist/browser/query/query.schema.js

@@ -0,0 +1,70 @@
+// src/query/query.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var QueryTypeEnum = defineEnum("QueryType", [
+  "SQL",
+  "METRIC",
+  "AGGREGATION",
+  "CUSTOM"
+]);
+
+// src/query/query.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var QueryModel = defineSchemaModel({
+  name: "QueryModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var QueryResultModel = defineSchemaModel({
+  name: "QueryResultModel",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    columns: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    rowCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    executionTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var CreateQueryInputModel = defineSchemaModel({
+  name: "CreateQueryInput",
+  fields: {
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: QueryTypeEnum, isOptional: false },
+    definition: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    sql: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metricIds: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    cacheTtlSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    isShared: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+var ExecuteQueryInputModel = defineSchemaModel({
+  name: "ExecuteQueryInput",
+  fields: {
+    queryId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    parameters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    dateRange: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    filters: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    forceRefresh: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+export {
+  QueryResultModel,
+  QueryModel,
+  ExecuteQueryInputModel,
+  CreateQueryInputModel
+};

package/dist/browser/query/query.test-spec.js

@@ -0,0 +1,113 @@
+// src/query/query.test-spec.ts
+import { defineTestSpec } from "@contractspec/lib.contracts";
+var CreateQueryTest = defineTestSpec({
+  meta: {
+    key: "analytics.query.create.test",
+    version: "1.0.0",
+    title: "Create Query Test",
+    description: "Verifies query creation flow",
+    owners: ["@example.analytics-dashboard"],
+    tags: ["analytics", "query", "test"],
+    stability: "stable"
+  },
+  target: {
+    type: "operation",
+    operation: { key: "analytics.query.create", version: "1.0.0" }
+  },
+  scenarios: [
+    {
+      key: "success",
+      description: "Successfully create a query",
+      when: {
+        operation: { key: "analytics.query.create", version: "1.0.0" },
+        input: {
+          name: "Revenue Query",
+          sql: "SELECT * FROM revenue"
+        }
+      },
+      then: [
+        {
+          type: "expectOutput",
+          match: {
+            name: "Revenue Query",
+            type: "sql"
+          }
+        }
+      ]
+    },
+    {
+      key: "error-invalid-sql",
+      description: "Fail with invalid SQL",
+      when: {
+        operation: { key: "analytics.query.create", version: "1.0.0" },
+        input: {
+          name: "Bad Query",
+          sql: ""
+        }
+      },
+      then: [
+        {
+          type: "expectError",
+          messageIncludes: "VALIDATION_ERROR"
+        }
+      ]
+    }
+  ]
+});
+var ExecuteQueryTest = defineTestSpec({
+  meta: {
+    key: "analytics.query.execute.test",
+    version: "1.0.0",
+    title: "Execute Query Test",
+    description: "Verifies query execution",
+    owners: ["@example.analytics-dashboard"],
+    tags: ["analytics", "query", "test"],
+    stability: "stable"
+  },
+  target: {
+    type: "operation",
+    operation: { key: "analytics.query.execute", version: "1.0.0" }
+  },
+  scenarios: [
+    {
+      key: "success",
+      description: "Successfully execute query",
+      when: {
+        operation: { key: "analytics.query.execute", version: "1.0.0" },
+        input: {
+          queryId: "q-123",
+          params: { limit: 10 }
+        }
+      },
+      then: [
+        {
+          type: "expectOutput",
+          match: {
+            rowCount: 1
+          }
+        }
+      ]
+    },
+    {
+      key: "error-query-not-found",
+      description: "Fail when query not found",
+      when: {
+        operation: { key: "analytics.query.execute", version: "1.0.0" },
+        input: {
+          queryId: "q-999",
+          params: {}
+        }
+      },
+      then: [
+        {
+          type: "expectError",
+          messageIncludes: "NOT_FOUND"
+        }
+      ]
+    }
+  ]
+});
+export {
+  ExecuteQueryTest,
+  CreateQueryTest
+};