@tstdl/base 0.92.137 → 0.92.139

package/examples/document-management/main.d.ts

@@ -1,20 +1,22 @@
 import '../../polyfills.js';
-import type { DocumentCollection, DocumentWorkflowStep } from '../../document-management/index.js';
-import { DocumentManagementAncillaryService, type DocumentCollectionMetadata } from '../../document-management/server/index.js';
+import type { DocumentCollection } from '../../document-management/index.js';
+import { DocumentManagementAncillaryService, DocumentManagementAuthorizationService, type DocumentCollectionMetadata } from '../../document-management/server/index.js';
 export declare class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
     _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
-    getSubject(_token?: unknown): string;
-    canCreateDocuments(_collectionId: string, _token?: unknown): boolean;
-    canUpdateDocuments(_collectionId: string, _token?: unknown): boolean;
-    canDeleteDocuments(_collectionId: string, _token?: unknown): boolean;
-    canAssignDocuments(_collectionId: string, _token?: unknown): boolean;
-    canManageRequests(_collectionId: string, _token?: unknown): boolean;
-    canReadCollection(_collectionId: string, _token?: unknown): boolean;
-    canApproveDocument(_documentId: string, _token?: unknown): boolean;
-    canRejectDocument(_documentId: string, _token?: unknown): boolean;
-    canManageCategoriesAndTypes(_token?: unknown): boolean;
-    canReadDocumentRequestsTemplates(_token?: unknown): boolean;
-    canManageDocumentRequestsTemplates(_token?: unknown): boolean;
-    canManageValidationDefinitions(_token?: unknown): boolean;
-    canProgressDocumentWorkflow(_documentId: string, _currentWorkflowStep: DocumentWorkflowStep, _token?: unknown): boolean;
+}
+export declare class AllowAllDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
+    getSubject(): string;
+    canReadCollection(): boolean;
+    canCreateDocuments(): boolean;
+    canUpdateDocuments(): boolean;
+    canDeleteDocuments(): boolean;
+    canAssignDocuments(): boolean;
+    canApproveDocument(): boolean;
+    canRejectDocument(): boolean;
+    canManageRequests(): boolean;
+    canManageCategoriesAndTypes(): boolean;
+    canReadDocumentRequestsTemplates(): boolean;
+    canManageDocumentRequestsTemplates(): boolean;
+    canManageValidationDefinitions(): boolean;
+    canProgressDocumentWorkflow(): boolean;
 }

package/examples/document-management/main.js

@@ -9,8 +9,10 @@ import { configureAiService } from '../../ai/index.js';
 import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
 import { Application } from '../../application/application.js';
-import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentManagementApiController, DocumentRequestService } from '../../document-management/server/index.js';
-import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
+import { configureTstdl } from '../../core.js';
+import { configureDocumentManagement } from '../../document-management/server/configure.js';
+import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentManagementApiController, DocumentManagementAuthorizationService, DocumentRequestService } from '../../document-management/server/index.js';
+import { migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { Injector, Singleton } from '../../injector/index.js';
@@ -21,8 +23,7 @@ import { configureS3ObjectStorage } from '../../object-storage/index.js';
 import { configureOrm } from '../../orm/server/index.js';
 import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
-import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels } from './categories-and-types.js';
-import { configureTstdl } from '../../core.js';
+import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels, TstdlDocumentTypeProperties } from './categories-and-types.js';
 const config = {
     database: {
         host: string('DATABASE_HOST', '127.0.0.1'),
@@ -48,30 +49,35 @@ const config = {
         bucketPerModule: boolean('S3_BUCKET_PER_MODULE', true),
     },
 };
-const userId = crypto.randomUUID();
 let ExampleDocumentManagementAncillaryService = class ExampleDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
     _resolveMetadata(collections) {
         return collections.map((collection) => ({ name: collection.id.split('-')[0], group: null }));
     }
-    getSubject(_token) { return userId; }
-    canCreateDocuments(_collectionId, _token) { return true; }
-    canUpdateDocuments(_collectionId, _token) { return true; }
-    canDeleteDocuments(_collectionId, _token) { return true; }
-    canAssignDocuments(_collectionId, _token) { return true; }
-    canManageRequests(_collectionId, _token) { return true; }
-    canReadCollection(_collectionId, _token) { return true; }
-    canApproveDocument(_documentId, _token) { return true; }
-    canRejectDocument(_documentId, _token) { return true; }
-    canManageCategoriesAndTypes(_token) { return true; }
-    canReadDocumentRequestsTemplates(_token) { return true; }
-    canManageDocumentRequestsTemplates(_token) { return true; }
-    canManageValidationDefinitions(_token) { return true; }
-    canProgressDocumentWorkflow(_documentId, _currentWorkflowStep, _token) { return true; }
 };
 ExampleDocumentManagementAncillaryService = __decorate([
     Singleton()
 ], ExampleDocumentManagementAncillaryService);
 export { ExampleDocumentManagementAncillaryService };
+let AllowAllDocumentManagementAuthorizationService = class AllowAllDocumentManagementAuthorizationService extends DocumentManagementAuthorizationService {
+    getSubject() { return '00000000-0000-0000-0000-000000000000'; }
+    canReadCollection() { return true; }
+    canCreateDocuments() { return true; }
+    canUpdateDocuments() { return true; }
+    canDeleteDocuments() { return true; }
+    canAssignDocuments() { return true; }
+    canApproveDocument() { return true; }
+    canRejectDocument() { return true; }
+    canManageRequests() { return true; }
+    canManageCategoriesAndTypes() { return true; }
+    canReadDocumentRequestsTemplates() { return true; }
+    canManageDocumentRequestsTemplates() { return true; }
+    canManageValidationDefinitions() { return true; }
+    canProgressDocumentWorkflow() { return true; }
+};
+AllowAllDocumentManagementAuthorizationService = __decorate([
+    Singleton()
+], AllowAllDocumentManagementAuthorizationService);
+export { AllowAllDocumentManagementAuthorizationService };
 async function bootstrap() {
     const injector = inject(Injector);
     configureTstdl();
@@ -89,6 +95,7 @@ async function bootstrap() {
     });
     configureDocumentManagement({
         ancillaryService: ExampleDocumentManagementAncillaryService,
+        authorizationService: AllowAllDocumentManagementAuthorizationService,
         fileObjectStorageModule: 'documents',
         fileUploadObjectStorageModule: 'document-uploads',
         filePreviewObjectStorageModule: 'document-previews',
@@ -122,7 +129,7 @@ async function bootstrap() {
 }
 async function main() {
     const [documentManagementService, documentCollectionService] = await injectManyAsync(DocumentManagementService, DocumentCollectionService, DocumentCategoryTypeService, DocumentRequestService);
-    const { categories, types } = await documentManagementService.initializeCategoriesAndTypes(TstdlDocumentCategoryLabels, TstdlCategoryParents, TstdlDocumentTypeLabels, TstdlDocumentTypeCategories);
+    const { categories, types } = await documentManagementService.initializeCategoriesAndTypes(TstdlDocumentCategoryLabels, TstdlCategoryParents, TstdlDocumentTypeLabels, TstdlDocumentTypeCategories, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeProperties);
     const collectionCount = await documentCollectionService.repository.count();
     for (let i = 0; i < (3 - collectionCount); i++) {
         await documentCollectionService.createCollection(null);

package/file/mime-type.d.ts

@@ -1,2 +1,3 @@
-export declare function getMimeType(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<string>;
+export declare function getMimeType(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<string | undefined>;
+export declare function getMimeType<F>(file: string | Uint8Array | ReadableStream<Uint8Array>, fallback: F): Promise<string | F>;
 export declare function getMimeTypeExtensions(mimeType: string): string[];

package/file/mime-type.js

@@ -1,23 +1,15 @@
-import { spawnCommand } from '../process/spawn.js';
-import { isDefined, isString } from '../utils/type-guards.js';
+import { fileTypeFromBuffer, fileTypeFromFile, fileTypeFromStream } from 'file-type';
+import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { match } from 'ts-pattern';
 import { mimeTypesMap } from './mime-types.js';
-export async function getMimeType(file) {
-    const path = isString(file) ? file : '-';
-    const data = isString(file) ? undefined : file;
-    return spawnFileCommand(['--brief', '--mime-type', path], data);
+export async function getMimeType(file, fallback) {
+    const result = await match(file)
+        .when(isString, async (f) => await fileTypeFromFile(f))
+        .when(isUint8Array, async (f) => await fileTypeFromBuffer(f))
+        .when((isReadableStream), async (f) => await fileTypeFromStream(f))
+        .exhaustive();
+    return result?.mime ?? fallback;
 }
 export function getMimeTypeExtensions(mimeType) {
     return mimeTypesMap.get(mimeType) ?? [];
 }
-async function spawnFileCommand(args, file) {
-    const process = await spawnCommand('file', args);
-    if (isDefined(file)) {
-        process.autoWrite(file);
-    }
-    await process.wait({ throwOnNonZeroExitCode: true });
-    const output = await process.readOutput();
-    if (output.includes('file or directory')) {
-        throw new Error(output.trim());
-    }
-    return output.trim();
-}

package/file/mime-types.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { objectEntries } from '../utils/object/object.js';
 export const mimeTypes = {
     'application/andrew-inset': ['ez'],
@@ -767,6 +766,6 @@ export const mimeTypes = {
     'video/x-msvideo': ['avi'],
     'video/x-sgi-movie': ['movie'],
     'video/x-smv': ['smv'],
-    'x-conference/x-cooltalk': ['ice']
+    'x-conference/x-cooltalk': ['ice'],
 };
 export const mimeTypesMap = new Map(objectEntries(mimeTypes));

package/http/server/http-server-response.js

@@ -19,8 +19,8 @@ export class HttpServerResponse {
             ...options,
             headers: {
                 Location: url,
-                ...options?.headers
-            }
+                ...options?.headers,
+            },
         });
     }
     update(options) {

package/orm/sqls.d.ts

@@ -66,5 +66,11 @@ export declare function numNulls(...columns: Column[]): SQL<number>;
  * @returns A Drizzle SQL object representing the count of non-nulls.
  */
 export declare function numNonNulls(...columns: Column[]): SQL<number>;
-export declare function least<T extends (Column | SQL | number)>(...values: T[]): SQL<SelectResultField<T>>;
-export declare function greatest<T extends (Column | SQL | number)>(...values: T[]): SQL<SelectResultField<T>>;
+export declare function least<T extends (Column | SQL | number)[]>(...values: T): SQL<SelectResultField<{
+    [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
+}[number]>>;
+export declare function least<T>(...values: T[]): SQL<SelectResultField<T>>;
+export declare function greatest<T extends (Column | SQL | number)[]>(...values: T): SQL<SelectResultField<{
+    [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
+}[number]>>;
+export declare function greatest<T>(...values: T[]): SQL<SelectResultField<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.137",
+  "version": "0.92.139",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,6 +152,7 @@
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
     "drizzle-orm": "^0.43",
+    "file-type": "^21.0",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",
@@ -183,7 +184,7 @@
     "concurrently": "9.1",
     "drizzle-kit": "0.31",
     "eslint": "9.27",
-    "globals": "16.1",
+    "globals": "16.2",
     "tsc-alias": "1.8",
     "typedoc-plugin-missing-exports": "4.0",
     "typescript": "5.8",

package/schema/converters/openapi-converter.js

@@ -20,7 +20,7 @@ export function convertToOpenApiSchema(testable) {
         ...openApiSchema,
         ...(hasOwnProperty(openApiSchema, 'nullable') ? undefined : { nullable: false }),
         ...(isNotNull(schema.description) ? { description: schema.description } : undefined),
-        ...(isDefined(schema.example) ? { example: schema.example } : undefined)
+        ...(isDefined(schema.example) ? { example: schema.example } : undefined),
     };
 }
 function convertToOpenApiSchemaBase(schema) {
@@ -32,36 +32,36 @@ function convertToOpenApiSchemaBase(schema) {
             properties: fromEntries(convertedEntries),
             required: entries
                 .filter(([, propertySchema]) => !(propertySchema instanceof OptionalSchema) && !((propertySchema instanceof NullableSchema) && (propertySchema.schema instanceof OptionalSchema)))
-                .map(([property]) => property)
+                .map(([property]) => property),
         };
     }
     if (schema instanceof StringSchema) {
         return {
-            type: 'string'
+            type: 'string',
         };
     }
     if (schema instanceof DateSchema) {
         return {
             type: 'string',
-            format: 'date-time'
+            format: 'date-time',
         };
     }
     if (schema instanceof NumberSchema) {
         return {
             type: schema.integer ? 'integer' : 'number',
             ...(isNumber(schema.minimum) ? { minimum: schema.minimum } : undefined),
-            ...(isNumber(schema.maximum) ? { maximum: schema.maximum } : undefined)
+            ...(isNumber(schema.maximum) ? { maximum: schema.maximum } : undefined),
         };
     }
     if (schema instanceof BooleanSchema) {
         return {
-            type: 'boolean'
+            type: 'boolean',
         };
     }
     if (schema instanceof LiteralSchema) {
         return {
             type: typeof schema.value,
-            enum: [schema.value]
+            enum: [schema.value],
         };
     }
     if (schema instanceof ArraySchema) {
@@ -69,19 +69,22 @@ function convertToOpenApiSchemaBase(schema) {
             type: 'array',
             items: convertToOpenApiSchema(schema.itemSchema),
             ...(isNumber(schema.minimum) ? { minItems: schema.minimum } : undefined),
-            ...(isNumber(schema.maximum) ? { maxItems: schema.maximum } : undefined)
+            ...(isNumber(schema.maximum) ? { maxItems: schema.maximum } : undefined),
         };
     }
     if (schema instanceof EnumerationSchema) {
         const hasString = schema.allowedValues.some(isString);
         const hasNumber = schema.allowedValues.some(isNumber);
+        if (schema.allowedValues.length === 0) {
+            throw new NotSupportedError('Enum must have at least one value.');
+        }
         if (!hasString && !hasNumber) {
             throw new NotSupportedError('Enum must be either string or number but not both.');
         }
         return {
             type: hasString ? 'string' : 'number',
             format: 'enum',
-            enum: schema.allowedValues
+            enum: schema.allowedValues,
         };
     }
     if (schema instanceof NullableSchema) {
@@ -89,17 +92,17 @@ function convertToOpenApiSchemaBase(schema) {
             const enumSchema = convertToOpenApiSchema(schema.schema);
             return {
                 ...enumSchema,
-                nullable: true
+                nullable: true,
             };
         }
         return {
             ...convertToOpenApiSchema(schema.schema),
-            nullable: true
+            nullable: true,
         };
     }
     if (schema instanceof UnionSchema) {
         return {
-            oneOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema))
+            oneOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema)),
         };
     }
     throw new NotSupportedError(`Schema "${schema.name}" not supported.`);