@appsemble/lang-sdk 0.36.10-test.0 → 0.36.10-test.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/lang-sdk",
-  "version": "0.36.10-test.0",
+  "version": "0.36.10-test.1",
   "description": "Language SDK for Appsemble",
   "keywords": [
     "app",

package/schemas/ResourceDefinition.js

@@ -82,6 +82,17 @@ name of the resource and how it should behave.
                 },
             },
         },
+        unique: {
+            type: 'array',
+            minItems: 1,
+            uniqueItems: true,
+            items: {
+                oneOf: [
+                    { type: 'string' },
+                    { type: 'array', items: { type: 'string' }, minItems: 2, uniqueItems: true },
+                ],
+            },
+        },
         positioning: {
             type: 'boolean',
             default: false,

package/types/resource.d.ts

@@ -1,9 +1,11 @@
 import { type OpenAPIV3 } from 'openapi-types';
 import { type HTTPMethods } from './http.js';
 import { type Remapper } from './remapper.js';
+export declare function inferResourceUniqueFieldType(propertySchema: OpenAPIV3.SchemaObject | undefined): string;
 export type ResourceViewAction = 'get' | 'query';
 export type OwnResourceAction = ResourceViewAction | 'delete' | 'patch' | 'update';
 export type ResourceAction = ResourceViewAction | 'create' | 'delete' | 'history.get' | 'patch' | 'update.positions' | 'update';
+export type ResourceUniqueConstraint = string | [string, string, ...string[]];
 export interface ResourceDefinition {
     /**
      * A definition of how versioning should happen for instances of this resource.
@@ -70,6 +72,13 @@ export interface ResourceDefinition {
      * The references this resources has to other resources.
      */
     references?: Record<string, ResourceReference>;
+    /**
+     * The unique constraints that should be enforced across all instances of this resource.
+     *
+     * Each constraint can be a single field name or an array of field names for a composite unique
+     * key.
+     */
+    unique?: ResourceUniqueConstraint[];
     /**
      * A time string representing when a resource should expire.
      *

package/types/resource.js

@@ -1,2 +1,22 @@
-export {};
+const supportedResourceUniqueFieldTypes = new Set(['boolean', 'integer', 'number', 'string']);
+export function inferResourceUniqueFieldType(propertySchema) {
+    if (propertySchema?.type && supportedResourceUniqueFieldTypes.has(propertySchema.type)) {
+        return propertySchema.type;
+    }
+    const enumValues = propertySchema?.enum;
+    if (!Array.isArray(enumValues) || !enumValues.length) {
+        return '';
+    }
+    const types = new Set(enumValues.map((value) => typeof value));
+    if (types.size !== 1) {
+        return '';
+    }
+    if (types.has('string') || types.has('boolean')) {
+        return typeof enumValues[0];
+    }
+    if (types.has('number')) {
+        return enumValues.every(Number.isInteger) ? 'integer' : 'number';
+    }
+    return '';
+}
 //# sourceMappingURL=resource.js.map

package/validation.js

@@ -2,13 +2,15 @@ import cronParser from 'cron-parser';
 import { ValidationError, Validator } from 'jsonschema';
 import languageTags from 'language-tags';
 import { getAppInheritedRoles, getAppPossibleGuestPermissions, getAppPossiblePermissions, getAppRolePermissions, } from './authorization.js';
+import { BlockParamInstanceValidator } from './BasicValidator.js';
 import { getAppBlocks, normalizeBlockName } from './blockUtils.js';
+import { partialNormalized } from './constants/index.js';
 import { findPageByName } from './findPageByName.js';
-import { BlockParamInstanceValidator, normalize, partialNormalized } from './index.js';
 import { iterApp } from './iterApp.js';
 import { has } from './miscellaneous.js';
+import { normalize } from './normalize.js';
 import { serverActions } from './serverActions.js';
-import { PredefinedAppRole, predefinedAppRolePermissions, } from './types/index.js';
+import { PredefinedAppRole, predefinedAppRolePermissions, inferResourceUniqueFieldType, } from './types/index.js';
 const allResourcePermissionPattern = /^\$resource:all:(get|history:get|query|create|delete|patch|update)$/;
 const resourcePermissionPattern = /^\$resource:[^:]+:(get|history:get|query|create|delete|patch|update)$/;
 const allOwnResourcePermissionPattern = /^\$resource:all:own:(get|query|delete|patch|update)$/;
@@ -129,6 +131,7 @@ function validateResourceSchemas(definition, report) {
             continue;
         }
         const { enforceOrderingGroupByFields, positioning, schema } = resource;
+        const resourcePrefix = ['resources', resourceName];
         const prefix = ['resources', resourceName, 'schema'];
         if (!positioning && enforceOrderingGroupByFields?.length) {
             report(enforceOrderingGroupByFields, 'must set positioning to true', [
@@ -155,6 +158,7 @@ function validateResourceSchemas(definition, report) {
             'expires',
             // XXX: is position reserved?
         ]);
+        const uniqueReservedKeywords = new Set([...reservedKeywords, 'id', '$created', '$updated']);
         if (reservedKeywords.has(resourceName)) {
             report(schema, 'is a reserved keyword', ['resources', resourceName]);
         }
@@ -231,6 +235,38 @@ function validateResourceSchemas(definition, report) {
                 }
             }
         }
+        if ('unique' in resource && resource.unique !== undefined) {
+            const propertyNames = new Set(Object.keys(schema.properties ?? {}));
+            const seenConstraints = new Set();
+            for (const [constraintId, constraint] of resource.unique.entries()) {
+                const fields = [].concat(constraint);
+                const normalizedConstraint = fields.toSorted().join('\0');
+                if (seenConstraints.has(normalizedConstraint)) {
+                    report(constraint, 'duplicates another unique constraint', [
+                        ...resourcePrefix,
+                        'unique',
+                        constraintId,
+                    ]);
+                }
+                seenConstraints.add(normalizedConstraint);
+                for (const [fieldId, field] of fields.entries()) {
+                    const path = Array.isArray(constraint)
+                        ? [...resourcePrefix, 'unique', constraintId, fieldId]
+                        : [...resourcePrefix, 'unique', constraintId];
+                    if (uniqueReservedKeywords.has(field)) {
+                        report(field, `unique field cannot be a reserved keyword: ${field}`, path);
+                    }
+                    if (!propertyNames.has(field)) {
+                        report(field, `unique field must be defined in properties: ${field}`, path);
+                    }
+                    if (propertyNames.has(field) &&
+                        !uniqueReservedKeywords.has(field) &&
+                        !inferResourceUniqueFieldType(schema.properties?.[field])) {
+                        report(field, `unique field must have type string, integer, number, boolean, or enum: ${field}`, path);
+                    }
+                }
+            }
+        }
     }
 }
 function validateController(definition, controllerImplementations, report) {
@@ -416,8 +452,8 @@ function validateGridLayout(definition, report) {
             if (page.type === 'tabs') {
                 const tabsPage = page;
                 if (tabsPage.tabs) {
-                    for (const [tabIdx, tab] of tabsPage.tabs.entries()) {
-                        validateSubPageLayout(tab.layout, tab.blocks, report, [...path, 'tabs', tabIdx]);
+                    for (const [tabId, tab] of tabsPage.tabs.entries()) {
+                        validateSubPageLayout(tab.layout, tab.blocks, report, [...path, 'tabs', tabId]);
                     }
                 }
                 else if (tabsPage.definition?.foreach) {
@@ -428,8 +464,8 @@ function validateGridLayout(definition, report) {
             // Flow page
             if (page.type === 'flow') {
                 const flowPage = page;
-                for (const [stepIdx, step] of flowPage.steps.entries()) {
-                    validateSubPageLayout(step.layout, step.blocks, report, [...path, 'steps', stepIdx]);
+                for (const [stepId, step] of flowPage.steps.entries()) {
+                    validateSubPageLayout(step.layout, step.blocks, report, [...path, 'steps', stepId]);
                 }
                 return;
             }