@nexia/sdk 0.5.0 → 0.6.1

package/README.md

@@ -0,0 +1,9 @@
+# @nexia/sdk
+
+Public frontend contracts for Nexia App Packages. Import supported contracts from the package root, `/host` or `/testing`. This package does not contain the Nexia Core workspace runtime.
+
+## Developer support / 개발자 지원
+
+Report SDK, setup, CLI, Docker, AI-tool and sandbox problems in the [central developer support tracker](https://github.com/nexia-cloud-os/developer-support/issues). Search existing issues first and include package versions and minimal reproduction steps. Never attach credentials, private Core source or customer data.
+
+SDK·개발환경·CLI·Docker·AI 도구·샌드박스 문제는 [통합 이슈 창구](https://github.com/nexia-cloud-os/developer-support/issues)에 신고하세요. 기존 이슈를 먼저 검색하고 패키지 버전과 최소 재현 단계를 포함하세요. 인증 정보, 비공개 Core 소스와 고객 데이터는 첨부하지 마세요.

package/dist/index.d.ts

@@ -19,7 +19,7 @@ export type { SubjectPopulation } from "./permissions";
 export { formatNumber } from "./number";
 export type { NumberLike } from "./number";
 export { CompositionSpecValidationError, parseCompositionSpec, } from "./resource-composition";
-export type { CompositionSpec, CompositionSpecV3, CompositionSpecV4 } from "./resource-composition";
+export type { CompositionSpec } from "./resource-composition";
 export { RESOURCE_PICKER_STALE_TIME_MS, RESOURCE_REFERENCE_STATUSES, allowsManualReferenceFallback, isResourceReferenceBlocked, isResourceReferenceStatus, parseResourceReferenceOptionPage, resourcePickerRevalidation, resourceReferencePickerQueryKey, resourceReferencePickerQueryRoot, resourceReferenceOptionsRoute, savedResourceReferencePresentation, } from "./resource-reference";
 export type { ResourceCreateDestination, ResourceCreateDestinationRegistration, ResourceCreateDestinationRegistry, } from "./resource-create-destination";
 export type { ResourcePickerQueryState, ResourcePickerRefetchOptions, ResourcePickerRevalidation, ResourceReferenceAvailability, ResourceReferenceIdentity, ResourceReferenceOption, ResourceReferenceOptionPage, ResourceReferenceOptionPageMeta, ResourceReferenceOptionsResponse, ResourceReferencePickerQueryScope, ResourceReferenceSelectorContext, ResourceReferenceStatus, } from "./resource-reference";

package/dist/resource-composition.d.ts

@@ -1,71 +1,23 @@
-interface CompositionSpecBody {
+/** Strict, presentation-free intent for one bounded read-only Resource composition. */
+interface CompositionSpecBase {
+    readonly schema_version: 1;
     readonly sources: readonly {
         readonly alias: string;
         readonly resource_key: string;
     }[];
-    readonly fields: readonly {
-        readonly source: string;
-        readonly field: string;
-    }[];
-    readonly filters: readonly {
-        readonly source: string;
-        readonly field: string;
-        readonly operator: 'eq' | 'in';
-        readonly value: string | number | boolean | readonly (string | number | boolean)[];
-    }[];
-    readonly dimensions: readonly {
-        readonly source: string;
-        readonly field: string;
-        readonly bucket: 'day' | 'week' | 'month' | null;
-    }[];
-    readonly measures: readonly {
-        readonly alias: string;
-        readonly source: string;
-        readonly field: string | null;
-        readonly operation: 'count' | 'distinct_count' | 'sum' | 'avg';
-        readonly result_type: 'integer' | 'decimal';
-        readonly null_behavior: 'zero' | 'null_if_empty';
-        readonly unit: string;
-    }[];
-    readonly result: {
-        readonly shape: 'rows' | 'aggregate';
-    };
-}
-/** Strict, presentation-free intent for one bounded read-only Resource composition. */
-export interface CompositionSpecV1 extends CompositionSpecBody {
-    readonly schema_version: 1;
-    readonly relationship: {
-        readonly key: string;
-    } | null;
-    readonly relationships?: never;
-}
-export interface CompositionSpecV2 extends CompositionSpecBody {
-    readonly schema_version: 2;
-    readonly relationship?: never;
-    readonly relationships: readonly [{
-        readonly key: string;
-    }, {
-        readonly key: string;
-    }];
-}
-export interface CompositionSpecV3 extends CompositionSpecBody {
-    readonly schema_version: 3;
-    readonly relationship?: never;
     readonly relationships: readonly {
         readonly key: string;
         readonly source: string;
         readonly target: string;
+        readonly match: 'preserve' | 'require' | 'exclude';
+        readonly time_field?: string;
     }[];
-}
-/** Advanced reports retain one strict CompositionSpec wire; Core gates live capabilities. */
-export interface CompositionSpecV4 {
-    readonly schema_version: 4;
-    readonly sources: CompositionSpecBody['sources'];
-    readonly relationships: readonly {
-        readonly key: string;
+    readonly population: {
+        readonly mode: 'anchor';
         readonly source: string;
-        readonly target: string;
-    }[];
+    } | {
+        readonly mode: 'union' | 'intersection';
+    };
     readonly fields: readonly ({
         readonly source: string;
         readonly field: string;
@@ -86,11 +38,18 @@ export interface CompositionSpecV4 {
     readonly limit: {
         readonly count: number;
     } | null;
+}
+export type CompositionSpec = (CompositionSpecBase & {
     readonly result: {
-        readonly shape: 'rows' | 'aggregate';
+        readonly shape: 'rows';
     };
-}
-export type CompositionSpec = CompositionSpecV1 | CompositionSpecV2 | CompositionSpecV3 | CompositionSpecV4;
+    readonly row_source: string;
+}) | (CompositionSpecBase & {
+    readonly result: {
+        readonly shape: 'aggregate';
+    };
+    readonly row_source?: never;
+});
 export declare class CompositionSpecValidationError extends Error {
     readonly code: 'invalid_shape' | 'unsupported_schema_version' | 'unknown_key' | 'invalid_identifier' | 'duplicate_identifier' | 'invalid_source_count' | 'unknown_source_alias' | 'relationship_required' | 'relationship_not_allowed' | 'invalid_filter_value' | 'invalid_measure' | 'result_shape_mismatch';
     readonly path: string;

package/dist/resource-composition.js

@@ -14,122 +14,13 @@ export class CompositionSpecValidationError extends Error {
  */
 export function parseCompositionSpec(value) {
     const candidate = plainObject(value, '$');
-    const schemaVersion = candidate.schema_version;
-    if (schemaVersion !== 1 && schemaVersion !== 2 && schemaVersion !== 3 && schemaVersion !== 4) {
-        fail('unsupported_schema_version', 'schema_version', 'Resource Composition schema_version must be 1, 2, 3, or 4.');
-    }
-    if (schemaVersion === 4)
-        return parseV4(candidate);
-    const root = object(candidate, '$', schemaVersion === 1 ? [
-        'schema_version',
-        'sources',
-        'relationship',
-        'fields',
-        'filters',
-        'dimensions',
-        'measures',
-        'result',
-    ] : [
-        'schema_version',
-        'sources',
-        'relationships',
-        'fields',
-        'filters',
-        'dimensions',
-        'measures',
-        'result',
-    ]);
-    const sourceValues = list(root.sources, 'sources');
-    if ((schemaVersion === 1 && (sourceValues.length < 1 || sourceValues.length > 2))
-        || (schemaVersion === 2 && sourceValues.length !== 3)
-        || (schemaVersion === 3 && sourceValues.length < 2)) {
-        fail('invalid_source_count', 'sources', schemaVersion === 1
-            ? 'Resource Composition schema v1 requires one or two sources.'
-            : (schemaVersion === 2
-                ? 'Resource Composition schema v2 requires exactly three sources.'
-                : 'Resource Composition schema v3 requires at least two sources.'));
-    }
-    if (schemaVersion === 1 && sourceValues.length === 2 && root.relationship === null) {
-        fail('relationship_required', 'relationship', 'Two-source Resource Composition requires one relationship.');
-    }
-    if (schemaVersion === 1 && sourceValues.length === 1 && root.relationship !== null) {
-        fail('relationship_not_allowed', 'relationship', 'Single-source Resource Composition cannot declare a relationship.');
-    }
-    const sourceAliases = new Set();
-    const resourceKeys = new Set();
-    const sources = sourceValues.map((value, index) => {
-        const path = `sources.${index}`;
-        const source = object(value, path, ['alias', 'resource_key']);
-        const alias = identifier(source.alias, `${path}.alias`, ALIAS_PATTERN);
-        const resourceKey = identifier(source.resource_key, `${path}.resource_key`, RESOURCE_KEY_PATTERN);
-        if (sourceAliases.has(alias) || (schemaVersion !== 3 && resourceKeys.has(resourceKey))) {
-            fail('duplicate_identifier', path, schemaVersion === 3
-                ? 'Resource Composition source aliases must be unique.'
-                : 'Resource Composition source aliases and Resource keys must be unique.');
-        }
-        sourceAliases.add(alias);
-        resourceKeys.add(resourceKey);
-        return { alias, resource_key: resourceKey };
-    });
-    const aliases = sources.map(({ alias }) => alias);
-    const fields = parseSelections(root.fields, 'fields', aliases);
-    const filters = list(root.filters, 'filters').map((value, index) => {
-        const path = `filters.${index}`;
-        const filter = object(value, path, ['source', 'field', 'operator', 'value']);
-        const operator = oneOf(filter.operator, `${path}.operator`, ['eq', 'in'], 'invalid_filter_value');
-        const filterValue = operator === 'in'
-            ? scalarList(filter.value, `${path}.value`)
-            : scalar(filter.value, `${path}.value`);
-        return {
-            source: source(filter.source, aliases, `${path}.source`),
-            field: identifier(filter.field, `${path}.field`, FIELD_PATTERN),
-            operator,
-            value: filterValue,
-        };
-    });
-    const dimensions = [];
-    const dimensionKeys = new Set();
-    for (const [index, value] of list(root.dimensions, 'dimensions').entries()) {
-        const path = `dimensions.${index}`;
-        const dimension = object(value, path, ['source', 'field', 'bucket']);
-        const selectedSource = source(dimension.source, aliases, `${path}.source`);
-        const field = identifier(dimension.field, `${path}.field`, FIELD_PATTERN);
-        const bucket = dimension.bucket === null
-            ? null
-            : oneOf(dimension.bucket, `${path}.bucket`, ['day', 'week', 'month']);
-        const key = `${selectedSource}.${field}`;
-        if (dimensionKeys.has(key))
-            fail('duplicate_identifier', path, 'Resource Composition entries must be unique.');
-        dimensionKeys.add(key);
-        dimensions.push({ source: selectedSource, field, bucket });
-    }
-    const measures = [];
-    const measureAliases = new Set();
-    for (const [index, value] of list(root.measures, 'measures').entries()) {
-        const measure = parseMeasure(value, index, aliases, measureAliases);
-        measures.push(measure);
-    }
-    const resultValue = object(root.result, 'result', ['shape']);
-    const result = { shape: oneOf(resultValue.shape, 'result.shape', ['rows', 'aggregate']) };
-    assertResultShape(result.shape, fields, dimensions, measures);
-    const body = {
-        sources,
-        fields,
-        filters,
-        dimensions,
-        measures,
-        result,
-    };
-    if (schemaVersion === 1) {
-        return { schema_version: 1, ...body, relationship: parseRelationship(root.relationship) };
-    }
-    if (schemaVersion === 2) {
-        return { schema_version: 2, ...body, relationships: parseRelationships(root.relationships) };
-    }
-    return { schema_version: 3, ...body, relationships: parseGraphRelationships(root.relationships, aliases) };
-}
-function parseV4(candidate) {
-    const root = object(candidate, '$', ['schema_version', 'sources', 'relationships', 'fields', 'timezone', 'where', 'dimensions', 'measures', 'having', 'derived', 'comparison', 'sort', 'limit', 'result']);
+    if (candidate.schema_version !== 1)
+        fail('unsupported_schema_version', 'schema_version', 'Resource Composition schema_version must be 1.');
+    const resultInput = object(candidate.result, 'result', ['shape']);
+    const declaredShape = oneOf(resultInput.shape, 'result.shape', ['rows', 'aggregate']);
+    const root = object(candidate, '$', declaredShape === 'rows'
+        ? ['schema_version', 'sources', 'relationships', 'population', 'row_source', 'fields', 'timezone', 'where', 'dimensions', 'measures', 'having', 'derived', 'comparison', 'sort', 'limit', 'result']
+        : ['schema_version', 'sources', 'relationships', 'population', 'fields', 'timezone', 'where', 'dimensions', 'measures', 'having', 'derived', 'comparison', 'sort', 'limit', 'result']);
     let nodes = 0;
     const boundedList = (value, path) => {
         const values = list(value, path);
@@ -141,7 +32,7 @@ function parseV4(candidate) {
         if (depth > 8 || ++nodes > 100)
             fail('invalid_shape', path, 'Resource Composition is too complex.');
     };
-    const scalarV4 = (value, path) => {
+    const scalar = (value, path) => {
         if ((typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') || (typeof value === 'number' && !Number.isFinite(value)) || (typeof value === 'string' && value.length > 512))
             fail('invalid_filter_value', path, 'Resource Composition scalar is invalid.');
         return value;
@@ -185,37 +76,41 @@ function parseV4(candidate) {
             const values = boundedList(item.value, `${path}.value`);
             if (values.length === 0)
                 fail('invalid_filter_value', `${path}.value`, 'The in filter requires a non-empty scalar list.');
-            predicateValue = values.map((entry) => scalarV4(entry, `${path}.value`));
+            predicateValue = values.map((entry) => scalar(entry, `${path}.value`));
         }
         else if (operator === 'between') {
             const bounds = object(item.value, `${path}.value`, ['from', 'to']);
-            scalarV4(bounds.from, `${path}.value.from`);
-            scalarV4(bounds.to, `${path}.value.to`);
+            scalar(bounds.from, `${path}.value.from`);
+            scalar(bounds.to, `${path}.value.to`);
         }
         else if (operator === 'is_null' || operator === 'not_null') {
             if (item.value !== null)
                 fail('invalid_filter_value', `${path}.value`, 'Null predicate requires null.');
         }
         else
-            scalarV4(item.value, `${path}.value`);
+            scalar(item.value, `${path}.value`);
         if (!aggregate)
             return { kind, target: target(item.target, `${path}.target`), operator, value: predicateValue };
         const aggregateTarget = object(item.target, `${path}.target`, ['kind', 'alias']);
         return { kind, target: { kind: oneOf(aggregateTarget.kind, `${path}.target.kind`, ['measure', 'derived']), alias: identifier(aggregateTarget.alias, `${path}.target.alias`, ALIAS_PATTERN) }, operator, value: predicateValue };
     };
+    const sourceAliases = new Set();
     const sources = boundedList(root.sources, 'sources').map((value, index) => {
-        const item = object(value, `sources.${index}`, ['alias', 'resource_key']);
-        return { alias: identifier(item.alias, `sources.${index}.alias`, ALIAS_PATTERN), resource_key: identifier(item.resource_key, `sources.${index}.resource_key`, RESOURCE_KEY_PATTERN) };
+        const path = `sources.${index}`;
+        const item = object(value, path, ['alias', 'resource_key']);
+        const alias = identifier(item.alias, `${path}.alias`, ALIAS_PATTERN);
+        if (sourceAliases.has(alias))
+            fail('duplicate_identifier', path, 'Resource Composition source aliases must be unique.');
+        sourceAliases.add(alias);
+        return { alias, resource_key: identifier(item.resource_key, `${path}.resource_key`, RESOURCE_KEY_PATTERN) };
     });
     if (sources.length === 0)
-        fail('invalid_source_count', 'sources', 'Resource Composition schema v4 requires at least one source.');
+        fail('invalid_source_count', 'sources', 'Resource Composition requires at least one source.');
     const aliases = sources.map((source) => source.alias);
-    if (new Set(aliases).size !== aliases.length)
-        fail('duplicate_identifier', 'sources', 'Resource Composition source aliases must be unique.');
     const relationships = boundedList(root.relationships, 'relationships');
     if (sources.length === 1 && relationships.length !== 0)
         fail('relationship_not_allowed', 'relationships', 'Single-source Resource Composition cannot declare relationships.');
-    const parsedRelationships = sources.length === 1 ? [] : parseGraphRelationships(relationships, aliases);
+    const parsedRelationships = parseGraphRelationships(relationships, aliases);
     const timezone = identifier(root.timezone, 'timezone', /^[A-Za-z_]+(?:\/[A-Za-z_+-]+)+$/);
     const fields = boundedList(root.fields, 'fields').map((value, index) => {
         node(`fields.${index}`);
@@ -227,6 +122,13 @@ function parseV4(candidate) {
         object(item, `fields.${index}`, ['source', 'field']);
         return { source: source(item.source, aliases, `fields.${index}.source`), field: identifier(item.field, `fields.${index}.field`, FIELD_PATTERN) };
     });
+    const fieldKeys = new Set();
+    fields.forEach((field, index) => {
+        const key = 'derived' in field ? `derived:${field.derived}` : `${field.source}.${field.field}`;
+        if (fieldKeys.has(key))
+            fail('duplicate_identifier', `fields.${index}`, 'Resource Composition entries must be unique.');
+        fieldKeys.add(key);
+    });
     const where = predicate(root.where, 'where');
     const dimensions = boundedList(root.dimensions, 'dimensions').map((value, index) => { node(`dimensions.${index}`); const item = object(value, `dimensions.${index}`, ['target', 'bucket']); return { target: target(item.target, `dimensions.${index}.target`), bucket: item.bucket === null ? null : oneOf(item.bucket, `dimensions.${index}.bucket`, ['day', 'week', 'month', 'quarter', 'year']) }; });
     const measures = boundedList(root.measures, 'measures').map((value, index) => {
@@ -387,128 +289,44 @@ function parseV4(candidate) {
         fail('result_shape_mismatch', 'result.shape', 'Row results cannot declare aggregate constructs.');
     if (shape === 'aggregate' && (fields.length || !measures.length))
         fail('result_shape_mismatch', 'result.shape', 'Aggregate results require measures and cannot declare row fields.');
-    return { schema_version: 4, sources, relationships: parsedRelationships, fields, timezone, where, dimensions, measures, having, derived, comparison, sort, limit: limit, result: { shape } };
-}
-function parseRelationship(value) {
-    if (value === null)
-        return null;
-    const relationship = object(value, 'relationship', ['key']);
-    return {
-        key: identifier(relationship.key, 'relationship.key', RELATIONSHIP_KEY_PATTERN),
-    };
-}
-function parseRelationships(value) {
-    const values = list(value, 'relationships');
-    if (values.length !== 2) {
-        fail('relationship_required', 'relationships', 'Resource Composition schema v2 requires exactly two relationships.');
-    }
-    const seen = new Set();
-    const relationships = values.map((value, index) => {
-        const path = `relationships.${index}`;
-        const relationship = object(value, path, ['key']);
-        const key = identifier(relationship.key, `${path}.key`, RELATIONSHIP_KEY_PATTERN);
-        if (seen.has(key))
-            fail('duplicate_identifier', `${path}.key`, 'Resource Composition entries must be unique.');
-        seen.add(key);
-        return { key };
-    });
-    return relationships;
+    const populationValue = plainObject(root.population, 'population');
+    const population = populationValue.mode === 'anchor'
+        ? (() => { object(populationValue, 'population', ['mode', 'source']); return { mode: 'anchor', source: source(populationValue.source, aliases, 'population.source') }; })()
+        : (() => { object(populationValue, 'population', ['mode']); const mode = oneOf(populationValue.mode, 'population.mode', ['union', 'intersection']); if (shape !== 'aggregate')
+            fail('result_shape_mismatch', 'population.mode', 'Union and intersection populations require aggregate results.'); return { mode }; })();
+    const row_source = shape === 'rows' ? source(root.row_source, aliases, 'row_source') : undefined;
+    return { schema_version: 1, sources, relationships: parsedRelationships, population, ...(row_source === undefined ? {} : { row_source }), fields, timezone, where, dimensions, measures, having, derived, comparison, sort, limit, result: { shape } };
 }
 function parseGraphRelationships(value, aliases) {
     const values = list(value, 'relationships');
-    if (values.length === 0) {
-        fail('relationship_required', 'relationships', 'Resource Composition schema v3 requires at least one relationship.');
+    if (values.length === 0 && aliases.length > 1) {
+        fail('relationship_required', 'relationships', 'Multi-source Resource Composition requires at least one relationship.');
     }
     const seen = new Set();
     return values.map((value, index) => {
         const path = `relationships.${index}`;
-        const relationship = object(value, path, ['key', 'source', 'target']);
+        const relationship = plainObject(value, path);
+        const { time_field: timeField, ...requiredRelationship } = relationship;
+        object(requiredRelationship, path, ['key', 'source', 'target', 'match']);
         const key = identifier(relationship.key, `${path}.key`, RELATIONSHIP_KEY_PATTERN);
         const sourceAlias = source(relationship.source, aliases, `${path}.source`);
         const targetAlias = source(relationship.target, aliases, `${path}.target`);
+        const match = oneOf(relationship.match, `${path}.match`, ['preserve', 'require', 'exclude']);
         const identity = `${key}\0${sourceAlias}\0${targetAlias}`;
         if (seen.has(identity))
             fail('duplicate_identifier', path, 'Resource Composition entries must be unique.');
         seen.add(identity);
-        return { key, source: sourceAlias, target: targetAlias };
+        return {
+            key,
+            source: sourceAlias,
+            target: targetAlias,
+            match,
+            ...(Object.hasOwn(relationship, 'time_field')
+                ? { time_field: identifier(timeField, `${path}.time_field`, FIELD_PATTERN) }
+                : {}),
+        };
     });
 }
-function parseSelections(value, path, aliases) {
-    const selections = [];
-    const keys = new Set();
-    for (const [index, itemValue] of list(value, path).entries()) {
-        const itemPath = `${path}.${index}`;
-        const item = object(itemValue, itemPath, ['source', 'field']);
-        const selectedSource = source(item.source, aliases, `${itemPath}.source`);
-        const field = identifier(item.field, `${itemPath}.field`, FIELD_PATTERN);
-        const key = `${selectedSource}.${field}`;
-        if (keys.has(key))
-            fail('duplicate_identifier', itemPath, 'Resource Composition entries must be unique.');
-        keys.add(key);
-        selections.push({ source: selectedSource, field });
-    }
-    return selections;
-}
-function parseMeasure(value, index, aliases, seenAliases) {
-    const path = `measures.${index}`;
-    const measure = object(value, path, [
-        'alias',
-        'source',
-        'field',
-        'operation',
-        'result_type',
-        'null_behavior',
-        'unit',
-    ]);
-    const alias = identifier(measure.alias, `${path}.alias`, ALIAS_PATTERN);
-    if (seenAliases.has(alias))
-        fail('duplicate_identifier', `${path}.alias`, 'Resource Composition entries must be unique.');
-    seenAliases.add(alias);
-    const selectedSource = source(measure.source, aliases, `${path}.source`);
-    const operation = oneOf(measure.operation, `${path}.operation`, ['count', 'distinct_count', 'sum', 'avg'], 'invalid_measure');
-    const resultType = oneOf(measure.result_type, `${path}.result_type`, ['integer', 'decimal'], 'invalid_measure');
-    const nullBehavior = oneOf(measure.null_behavior, `${path}.null_behavior`, ['zero', 'null_if_empty'], 'invalid_measure');
-    const unit = identifier(measure.unit, `${path}.unit`, UNIT_PATTERN, 'invalid_measure');
-    let field;
-    if (operation === 'count') {
-        if (measure.field !== null || resultType !== 'integer' || nullBehavior !== 'zero' || unit !== 'count') {
-            fail('invalid_measure', path, 'Count measures require a null field, integer result, zero null behavior, and count unit.');
-        }
-        field = null;
-    }
-    else if (operation === 'distinct_count') {
-        field = identifier(measure.field, `${path}.field`, FIELD_PATTERN);
-        if (resultType !== 'integer' || nullBehavior !== 'zero' || unit !== 'count') {
-            fail('invalid_measure', path, 'Distinct count measures require a field, integer result, zero null behavior, and count unit.');
-        }
-    }
-    else {
-        field = identifier(measure.field, `${path}.field`, FIELD_PATTERN);
-        if (resultType !== 'decimal' || nullBehavior !== 'null_if_empty' || unit === 'count') {
-            fail('invalid_measure', path, 'Sum and avg measures require a field, decimal result, null_if_empty behavior, and a declared unit.');
-        }
-    }
-    return {
-        alias,
-        source: selectedSource,
-        field,
-        operation,
-        result_type: resultType,
-        null_behavior: nullBehavior,
-        unit,
-    };
-}
-function assertResultShape(shape, fields, dimensions, measures) {
-    if (shape === 'rows') {
-        if (fields.length === 0 || dimensions.length > 0 || measures.length > 0) {
-            fail('result_shape_mismatch', 'result.shape', 'Row results require fields and cannot declare dimensions or measures.');
-        }
-        return;
-    }
-    if (fields.length > 0 || measures.length === 0) {
-        fail('result_shape_mismatch', 'result.shape', 'Aggregate results require measures and cannot declare row fields.');
-    }
-}
 function object(value, path, keys) {
     const record = plainObject(value, path);
     for (const key of Object.keys(record)) {

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@nexia/sdk",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Frontend contracts for Nexia App Packages",
   "license": "UNLICENSED",
   "type": "module",
+  "packageManager": "pnpm@11.17.0",
   "files": [
     "dist"
   ],
@@ -27,6 +28,17 @@
     }
   },
   "sideEffects": false,
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "test": "npm run build && node tests/WireValuesTest.mjs && node tests/ResourceCompositionFrontendContractsTest.mjs && node scripts/organization-target-contract.mjs",
+    "test:wire-values": "node tests/WireValuesTest.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:resource-composition": "pnpm run build && node tests/ResourceCompositionFrontendContractsTest.mjs",
+    "test:organization-target": "pnpm run build && node scripts/organization-target-contract.mjs",
+    "build:watch": "node scripts/build.mjs --watch",
+    "test:build-watch": "node --test tests/BuildWatchTest.mjs"
+  },
   "peerDependencies": {
     "@tanstack/react-query": "^5.99.0",
     "axios": "^1.11.0",
@@ -40,14 +52,15 @@
     "typescript": "^5.8.3"
   },
   "publishConfig": {
-    "registry": "https://npm.pkg.github.com"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   },
-  "scripts": {
-    "build": "node scripts/build.mjs",
-    "test": "npm run build && node tests/WireValuesTest.mjs && node tests/ResourceCompositionFrontendContractsTest.mjs && node scripts/organization-target-contract.mjs",
-    "test:wire-values": "node tests/WireValuesTest.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test:resource-composition": "pnpm run build && node tests/ResourceCompositionFrontendContractsTest.mjs",
-    "test:organization-target": "pnpm run build && node scripts/organization-target-contract.mjs"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nexia-cloud-os/app-sdk.git",
+    "directory": "packages/react"
+  },
+  "bugs": {
+    "url": "https://github.com/nexia-cloud-os/developer-support/issues"
   }
 }