@epsilon-asi/foundation 0.0.0-rc1 → 0.0.1-rc3

package/build/decorators/factory/clone.d.ts

@@ -0,0 +1,3 @@
+export declare function cloneDeep<T>(value: T, seen?: WeakMap<object, unknown>): T;
+export declare function deepFreeze<T>(value: T, seen?: WeakSet<object>): T;
+export declare function immutableClone<T>(value: T): T;

package/build/decorators/factory/clone.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeep = cloneDeep;
+exports.deepFreeze = deepFreeze;
+exports.immutableClone = immutableClone;
+function isObjectLike(value) {
+    return (typeof value === 'object' && value !== null) || typeof value === 'function';
+}
+function cloneDeep(value, seen = new WeakMap()) {
+    if (!isObjectLike(value))
+        return value;
+    if (typeof value === 'function')
+        return value;
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    if (value instanceof Map) {
+        const cloned = new Map();
+        seen.set(value, cloned);
+        for (const [key, mapValue] of value.entries()) {
+            cloned.set(cloneDeep(key, seen), cloneDeep(mapValue, seen));
+        }
+        return cloned;
+    }
+    if (value instanceof Set) {
+        const cloned = new Set();
+        seen.set(value, cloned);
+        for (const setValue of value.values()) {
+            cloned.add(cloneDeep(setValue, seen));
+        }
+        return cloned;
+    }
+    if (Array.isArray(value)) {
+        const cloned = [];
+        seen.set(value, cloned);
+        for (const item of value)
+            cloned.push(cloneDeep(item, seen));
+        return cloned;
+    }
+    const cloned = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, cloned);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined)
+            continue;
+        if ('value' in descriptor) {
+            descriptor.value = cloneDeep(descriptor.value, seen);
+        }
+        Object.defineProperty(cloned, key, descriptor);
+    }
+    return cloned;
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (!isObjectLike(value))
+        return value;
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    if (value instanceof Map) {
+        for (const [key, mapValue] of value.entries()) {
+            deepFreeze(key, seen);
+            deepFreeze(mapValue, seen);
+        }
+    }
+    else if (value instanceof Set) {
+        for (const setValue of value.values()) {
+            deepFreeze(setValue, seen);
+        }
+    }
+    else {
+        for (const key of Reflect.ownKeys(value)) {
+            deepFreeze(value[key], seen);
+        }
+    }
+    return Object.freeze(value);
+}
+function immutableClone(value) {
+    return deepFreeze(cloneDeep(value));
+}

package/build/decorators/factory/decoratorRegistry.d.ts

@@ -0,0 +1,2 @@
+import type { CreateDecoratorRegistryOptions, DecoratorRegistry, DecoratorSchema } from './types';
+export declare function createDecoratorRegistry<TSchema extends DecoratorSchema>(options?: CreateDecoratorRegistryOptions): DecoratorRegistry<TSchema>;

package/build/decorators/factory/decoratorRegistry.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoratorRegistry = createDecoratorRegistry;
+const clone_1 = require("./clone");
+const snapshot_1 = require("./snapshot");
+const symbolMetadata_1 = require("./symbolMetadata");
+function isPropertyKey(value) {
+    return typeof value === 'string' || typeof value === 'symbol';
+}
+function assertPropertyKey(value, decoratorName) {
+    if (isPropertyKey(value))
+        return value;
+    throw new TypeError(`Decorator "${decoratorName}" expected a string or symbol member key, but received ${typeof value}.`);
+}
+function parseDirectArgs(args, decoratorName) {
+    if (args.length === 0) {
+        return { metadata: undefined };
+    }
+    if (args.length === 1) {
+        return { metadata: args[0] };
+    }
+    return {
+        key: assertPropertyKey(args[0], decoratorName),
+        metadata: args[1],
+    };
+}
+function parseOnArgs(args, decoratorName) {
+    if (args.length === 0) {
+        throw new TypeError(`Decorator "${decoratorName}.on" requires a member key.`);
+    }
+    return {
+        key: assertPropertyKey(args[0], `${decoratorName}.on`),
+        metadata: args.length > 1 ? args[1] : undefined,
+    };
+}
+function assertContextKind(expectedKind, decoratorName, context) {
+    if (expectedKind === 'class' && context.kind === 'class')
+        return;
+    if (expectedKind === 'property' && context.kind === 'field')
+        return;
+    if (expectedKind === 'method' && context.kind === 'method')
+        return;
+    if (expectedKind === 'accessor' &&
+        (context.kind === 'accessor' || context.kind === 'getter' || context.kind === 'setter')) {
+        return;
+    }
+    throw new TypeError(`Decorator "${decoratorName}" can only be used on ${expectedKind} targets, but was used on ${context.kind}.`);
+}
+function getTargetConstructor(target) {
+    if (typeof target === 'function') {
+        return target;
+    }
+    const constructor = target.constructor;
+    return typeof constructor === 'function' ? constructor : undefined;
+}
+function getConstructorChain(constructor, includeInherited) {
+    if (!includeInherited)
+        return [constructor];
+    const chain = [];
+    let current = constructor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain.reverse();
+}
+function getOwnMetadataObject(constructor) {
+    if (!Object.prototype.hasOwnProperty.call(constructor, symbolMetadata_1.symbolMetadata)) {
+        return undefined;
+    }
+    const metadata = constructor[symbolMetadata_1.symbolMetadata];
+    return typeof metadata === 'object' && metadata !== null ? metadata : undefined;
+}
+function samePropertyKey(left, right) {
+    return left === right;
+}
+class ModernDecoratorRegistry {
+    constructor(options = {}) {
+        var _a, _b;
+        this.nextOrder = 0;
+        this.recordsByMetadata = new WeakMap();
+        this.namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
+        this.allowPrivateMembers = (_b = options.allowPrivateMembers) !== null && _b !== void 0 ? _b : false;
+    }
+    class(name) {
+        return this.createClassFactory(String(name));
+    }
+    for() {
+        return Object.freeze({
+            class: (name) => this.createScopedClassFactory(String(name)),
+            property: (name) => this.createPropertyFactory(String(name)),
+            method: (name) => this.createMethodFactory(String(name)),
+            accessor: (name) => this.createAccessorFactory(String(name)),
+        });
+    }
+    read(target, options = {}) {
+        var _a;
+        const constructor = getTargetConstructor(target);
+        if (constructor === undefined) {
+            return (0, snapshot_1.createSnapshot)([]);
+        }
+        const includeInherited = (_a = options.includeInherited) !== null && _a !== void 0 ? _a : true;
+        const constructors = getConstructorChain(constructor, includeInherited);
+        const records = [];
+        for (const current of constructors) {
+            const metadata = getOwnMetadataObject(current);
+            if (metadata === undefined)
+                continue;
+            const ownRecords = this.recordsByMetadata.get(metadata);
+            if (ownRecords !== undefined)
+                records.push(...ownRecords);
+        }
+        return (0, snapshot_1.createSnapshot)(records);
+    }
+    createClassFactory(decoratorName) {
+        const factory = ((...args) => {
+            const metadata = args.length === 0 ? undefined : args[0];
+            return (_value, context) => {
+                assertContextKind('class', decoratorName, context);
+                this.register(context.metadata, {
+                    kind: 'class',
+                    decorator: decoratorName,
+                    metadata,
+                    static: false,
+                    private: false,
+                });
+            };
+        });
+        return factory;
+    }
+    createScopedClassFactory(decoratorName) {
+        return ((...args) => {
+            const metadata = args.length === 0 ? undefined : args[0];
+            return (_value, context) => {
+                assertContextKind('class', decoratorName, context);
+                this.register(context.metadata, {
+                    kind: 'class',
+                    decorator: decoratorName,
+                    metadata,
+                    static: false,
+                    private: false,
+                });
+            };
+        });
+    }
+    createPropertyFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('property', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('property', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createMethodFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('method', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('method', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createAccessorFactory(decoratorName) {
+        const factory = ((...args) => {
+            const parsed = parseDirectArgs(args, decoratorName);
+            return this.createMemberDecorator('accessor', decoratorName, parsed);
+        });
+        factory.on = ((...args) => {
+            const parsed = parseOnArgs(args, decoratorName);
+            return this.createMemberDecorator('accessor', decoratorName, parsed);
+        });
+        return factory;
+    }
+    createMemberDecorator(kind, decoratorName, parsed) {
+        return (_value, context) => {
+            assertContextKind(kind, decoratorName, context);
+            if (context.private && !this.allowPrivateMembers) {
+                throw new Error(`Decorator "${decoratorName}" cannot be used on private member "${String(context.name)}" unless allowPrivateMembers is true.`);
+            }
+            if (parsed.key !== undefined && !samePropertyKey(parsed.key, context.name)) {
+                throw new Error(`Decorator "${decoratorName}" was keyed for "${String(parsed.key)}" but applied to "${String(context.name)}".`);
+            }
+            this.register(context.metadata, {
+                kind,
+                decorator: decoratorName,
+                metadata: parsed.metadata,
+                memberName: context.name,
+                static: context.static,
+                private: context.private,
+            });
+        };
+    }
+    register(metadataObject, record) {
+        const order = this.nextOrder;
+        this.nextOrder += 1;
+        const immutableRecord = Object.freeze(Object.assign(Object.assign({}, record), { id: `${this.namespace}:${record.kind}:${record.decorator}:${order}`, order, metadata: (0, clone_1.immutableClone)(record.metadata) }));
+        const existing = this.recordsByMetadata.get(metadataObject);
+        if (existing === undefined) {
+            this.recordsByMetadata.set(metadataObject, [immutableRecord]);
+        }
+        else {
+            existing.push(immutableRecord);
+        }
+    }
+}
+function createDecoratorRegistry(options = {}) {
+    return new ModernDecoratorRegistry(options);
+}

package/build/decorators/factory/examples/accessors.d.ts

@@ -0,0 +1,25 @@
+type ViewDecorators = {
+    class: {};
+    property: {};
+    method: {};
+    accessor: {
+        cached: {
+            metadata: {
+                ttlMs?: number;
+            };
+            target: string;
+        };
+    };
+};
+type UserViewContract = {
+    displayName: string;
+};
+declare const registry: import("../types").DecoratorRegistry<ViewDecorators>;
+declare class UserView implements UserViewContract {
+    accessor displayName: string;
+}
+export declare function readAccessorMetadata(): {
+    memberName: string | symbol;
+    ttlMs: number | undefined;
+}[];
+export { UserView, registry as accessorRegistry };

package/build/decorators/factory/examples/accessors.js

@@ -0,0 +1,87 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessorRegistry = exports.UserView = void 0;
+exports.readAccessorMetadata = readAccessorMetadata;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'accessor-example' });
+exports.accessorRegistry = registry;
+const View = registry.for();
+const Cached = View.accessor('cached');
+let UserView = (() => {
+    var _a, _UserView_displayName_accessor_storage;
+    let _displayName_decorators;
+    let _displayName_initializers = [];
+    let _displayName_extraInitializers = [];
+    return _a = class UserView {
+            get displayName() { return __classPrivateFieldGet(this, _UserView_displayName_accessor_storage, "f"); }
+            set displayName(value) { __classPrivateFieldSet(this, _UserView_displayName_accessor_storage, value, "f"); }
+            constructor() {
+                _UserView_displayName_accessor_storage.set(this, __runInitializers(this, _displayName_initializers, 'Ray'));
+                __runInitializers(this, _displayName_extraInitializers);
+            }
+        },
+        _UserView_displayName_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _displayName_decorators = [Cached('displayName', { ttlMs: 1000 })];
+            __esDecorate(_a, null, _displayName_decorators, { kind: "accessor", name: "displayName", static: false, private: false, access: { has: obj => "displayName" in obj, get: obj => obj.displayName, set: (obj, value) => { obj.displayName = value; } }, metadata: _metadata }, _displayName_initializers, _displayName_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+exports.UserView = UserView;
+function readAccessorMetadata() {
+    return registry.read(UserView).accessorRecords('cached').map((record) => {
+        if (record.memberName === undefined)
+            throw new Error('Missing member name.');
+        return {
+            memberName: record.memberName,
+            ttlMs: record.metadata.ttlMs,
+        };
+    });
+}

package/build/decorators/factory/examples/crud.d.ts

@@ -0,0 +1,50 @@
+type CrudController<TEntity, TCreateInput> = {
+    id: string;
+    get(id: string): Promise<TEntity>;
+    create(input: TCreateInput): Promise<TEntity>;
+};
+type UserDto = {
+    id: string;
+    email: string;
+};
+type CreateUserInput = {
+    email: string;
+};
+type UserCrudController = CrudController<UserDto, CreateUserInput>;
+type CrudDecorators = {
+    class: {
+        resource: {
+            metadata: {
+                name: string;
+            };
+        };
+    };
+    property: {
+        idField: {
+            metadata: undefined;
+            target: string;
+        };
+    };
+    method: {
+        route: {
+            metadata: {
+                method: 'GET' | 'POST';
+                path: string;
+            };
+            target: (...args: any[]) => Promise<unknown>;
+        };
+    };
+    accessor: {};
+};
+declare const registry: import("../types").DecoratorRegistry<CrudDecorators>;
+declare class UserCrud implements UserCrudController {
+    id: string;
+    get(id: string): Promise<UserDto>;
+    create(input: CreateUserInput): Promise<UserDto>;
+}
+export declare function buildCrudSummary(): {
+    resource: string;
+    routes: string[];
+    idFields: Array<string | symbol>;
+};
+export { UserCrud, registry as crudRegistry };

package/build/decorators/factory/examples/crud.js

@@ -0,0 +1,120 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crudRegistry = exports.UserCrud = void 0;
+exports.buildCrudSummary = buildCrudSummary;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'crud-example' });
+exports.crudRegistry = registry;
+const Crud = registry.for();
+const Resource = Crud.class('resource');
+const IdField = Crud.property('idField');
+const Route = Crud.method('route');
+let UserCrud = (() => {
+    let _classDecorators = [Resource({ name: 'users' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _get_decorators;
+    let _create_decorators;
+    var UserCrud = _classThis = class {
+        get(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id, email: 'ray@example.com' };
+            });
+        }
+        create(input) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id: 'new-id', email: input.email };
+            });
+        }
+        constructor() {
+            this.id = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _id_initializers, 'user-1'));
+            __runInitializers(this, _id_extraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "UserCrud");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _id_decorators = [IdField.on('id')];
+        _get_decorators = [Route('get', { method: 'GET', path: '/users/:id' })];
+        _create_decorators = [Route.on('create', { method: 'POST', path: '/users' })];
+        __esDecorate(_classThis, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        UserCrud = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return UserCrud = _classThis;
+})();
+exports.UserCrud = UserCrud;
+function buildCrudSummary() {
+    const snapshot = registry.read(UserCrud);
+    const resource = snapshot.firstClass('resource');
+    if (resource === undefined)
+        throw new Error('Missing @Resource metadata.');
+    return {
+        resource: resource.metadata.name,
+        routes: snapshot.methodRecords('route').map((record) => {
+            const metadata = record.metadata;
+            return `${metadata.method} ${metadata.path}`;
+        }),
+        idFields: snapshot.propertyRecords('idField').map((record) => {
+            if (record.memberName === undefined)
+                throw new Error('Missing member name.');
+            return record.memberName;
+        }),
+    };
+}

package/build/decorators/factory/examples/orm.d.ts

@@ -0,0 +1,45 @@
+type OrmDecorators = {
+    class: {
+        entity: {
+            metadata: {
+                table: string;
+            };
+        };
+    };
+    property: {
+        column: {
+            metadata: {
+                type: 'uuid' | 'varchar';
+                primary?: boolean;
+            };
+            target: string;
+        };
+        serializable: {
+            metadata: undefined;
+            target: unknown;
+        };
+    };
+    method: {};
+    accessor: {};
+};
+type UserModelContract = {
+    id: string;
+    email: string;
+};
+declare const registry: import("../types").DecoratorRegistry<OrmDecorators>;
+declare class UserModel implements UserModelContract {
+    id: string;
+    email: string;
+}
+export type TableColumn = {
+    name: string | symbol;
+    type: 'uuid' | 'varchar';
+    primary: boolean;
+};
+export type TableSchema = {
+    table: string;
+    columns: TableColumn[];
+    serializableFields: Array<string | symbol>;
+};
+export declare function buildUserTableSchema(): TableSchema;
+export { UserModel, registry as ormRegistry };