@epsilon-asi/foundation 0.0.1-testing

package/src/decorators/factory/types.ts

@@ -0,0 +1,259 @@
+export type AnyFunction = (...args: any[]) => any;
+export type Constructor<T = unknown> = abstract new (...args: any[]) => T;
+export type PublicMemberKey = string | symbol;
+
+export type DecorationKind = 'class' | 'property' | 'method' | 'accessor';
+
+export interface ClassDecoratorDefinition<TMetadata = unknown> {
+  metadata: TMetadata;
+}
+
+export interface PropertyDecoratorDefinition<TMetadata = unknown, TTarget = unknown> {
+  metadata: TMetadata;
+  target: TTarget;
+}
+
+export interface MethodDecoratorDefinition<
+  TMetadata = unknown,
+  TTarget extends AnyFunction = AnyFunction,
+> {
+  metadata: TMetadata;
+  target: TTarget;
+}
+
+export interface AccessorDecoratorDefinition<TMetadata = unknown, TTarget = unknown> {
+  metadata: TMetadata;
+  target: TTarget;
+}
+
+export type DecoratorSchema = {
+  class: Record<string, ClassDecoratorDefinition<any>>;
+  property: Record<string, PropertyDecoratorDefinition<any, any>>;
+  method: Record<string, MethodDecoratorDefinition<any, AnyFunction>>;
+  accessor: Record<string, AccessorDecoratorDefinition<any, any>>;
+};
+
+export type MetadataOf<TDefinition> = TDefinition extends { metadata: infer TMetadata }
+  ? TMetadata
+  : never;
+
+export type TargetOf<TDefinition> = TDefinition extends { target: infer TTarget }
+  ? TTarget
+  : unknown;
+
+export type StringKeyOf<TObject> = Extract<keyof TObject, string>;
+export type MemberKeyOf<TObject> = Extract<keyof TObject, PublicMemberKey>;
+
+export type KeysOfType<TObject, TValue> = {
+  [K in MemberKeyOf<TObject>]-?: TObject[K] extends TValue ? K : never;
+}[MemberKeyOf<TObject>];
+
+export type MethodKeysOfType<TObject, TValue extends AnyFunction> = {
+  [K in MemberKeyOf<TObject>]-?: TObject[K] extends TValue
+    ? TObject[K] extends AnyFunction
+      ? K
+      : never
+    : never;
+}[MemberKeyOf<TObject>];
+
+export type MetadataArgs<TMetadata> = [TMetadata] extends [undefined]
+  ? []
+  : [metadata: TMetadata];
+
+export type KeyedMetadataArgs<TKey extends PublicMemberKey, TMetadata> = [TMetadata] extends [undefined]
+  ? [key: TKey]
+  : [key: TKey, metadata: TMetadata];
+
+export type DirectKeyedMetadataArgs<TKey extends PublicMemberKey, TMetadata> = [
+  TMetadata,
+] extends [undefined]
+  ? [key: never]
+  : [key: TKey, metadata: TMetadata];
+
+export interface DecorationRecord {
+  id: string;
+  kind: DecorationKind;
+  decorator: string;
+  metadata: unknown;
+  memberName?: string | symbol;
+  static: boolean;
+  private: boolean;
+  order: number;
+}
+
+export interface RegistryMetadataSnapshot {
+  readonly all: readonly DecorationRecord[];
+  readonly classes: readonly DecorationRecord[];
+  readonly properties: readonly DecorationRecord[];
+  readonly methods: readonly DecorationRecord[];
+  readonly accessors: readonly DecorationRecord[];
+
+  firstClass(decorator: string): DecorationRecord | undefined;
+
+  classRecords(decorator?: string): readonly DecorationRecord[];
+  propertyRecords(decorator?: string): readonly DecorationRecord[];
+  methodRecords(decorator?: string): readonly DecorationRecord[];
+  accessorRecords(decorator?: string): readonly DecorationRecord[];
+
+  propertyMap(decorator?: string): ReadonlyMap<string | symbol, readonly DecorationRecord[]>;
+  methodMap(decorator?: string): ReadonlyMap<string | symbol, readonly DecorationRecord[]>;
+  accessorMap(decorator?: string): ReadonlyMap<string | symbol, readonly DecorationRecord[]>;
+}
+
+export interface CreateDecoratorRegistryOptions {
+  namespace?: string;
+  allowPrivateMembers?: boolean;
+}
+
+export interface RegistryReadOptions {
+  includeInherited?: boolean;
+}
+
+export type StandardClassDecorator<TExpected, TMetadata> = (
+  ...args: MetadataArgs<TMetadata>
+) => <TClass extends Constructor<TExpected>>(
+  value: TClass,
+  context: ClassDecoratorContext<TClass>,
+) => void;
+
+export type UnscopedClassDecoratorFactory<TMetadata> = <TExpected = unknown>(
+  ...args: MetadataArgs<TMetadata>
+) => <TClass extends Constructor<TExpected>>(
+  value: TClass,
+  context: ClassDecoratorContext<TClass>,
+) => void;
+
+export interface PropertyDecoratorFactory<TContract, TTarget, TMetadata> {
+  (...args: MetadataArgs<TMetadata>): (
+    value: undefined,
+    context: ClassFieldDecoratorContext<any, TTarget>,
+  ) => void;
+
+  <K extends KeysOfType<TContract, TTarget>>(
+    ...args: DirectKeyedMetadataArgs<K, TMetadata>
+  ): (
+    value: undefined,
+    context: ClassFieldDecoratorContext<TContract, TContract[K]> & { name: K },
+  ) => void;
+
+  on<K extends KeysOfType<TContract, TTarget>>(
+    ...args: KeyedMetadataArgs<K, TMetadata>
+  ): (
+    value: undefined,
+    context: ClassFieldDecoratorContext<TContract, TContract[K]> & { name: K },
+  ) => void;
+}
+
+export interface MethodDecoratorFactory<
+  TContract,
+  TTarget extends AnyFunction,
+  TMetadata,
+> {
+  (...args: MetadataArgs<TMetadata>): (
+    value: TTarget,
+    context: ClassMethodDecoratorContext<any, TTarget>,
+  ) => void;
+
+  <K extends MethodKeysOfType<TContract, TTarget>>(
+    ...args: DirectKeyedMetadataArgs<K, TMetadata>
+  ): (
+    value: TContract[K] extends AnyFunction ? TContract[K] : never,
+    context: ClassMethodDecoratorContext<
+      TContract,
+      TContract[K] extends AnyFunction ? TContract[K] : never
+    > & { name: K },
+  ) => void;
+
+  on<K extends MethodKeysOfType<TContract, TTarget>>(
+    ...args: KeyedMetadataArgs<K, TMetadata>
+  ): (
+    value: TContract[K] extends AnyFunction ? TContract[K] : never,
+    context: ClassMethodDecoratorContext<
+      TContract,
+      TContract[K] extends AnyFunction ? TContract[K] : never
+    > & { name: K },
+  ) => void;
+}
+
+export type GetterDecorator<TContract, TTarget, K extends PublicMemberKey = PublicMemberKey> = (
+  value: (this: TContract) => TTarget,
+  context: ClassGetterDecoratorContext<TContract, TTarget> & { name: K },
+) => void;
+
+export type SetterDecorator<TContract, TTarget, K extends PublicMemberKey = PublicMemberKey> = (
+  value: (this: TContract, value: TTarget) => void,
+  context: ClassSetterDecoratorContext<TContract, TTarget> & { name: K },
+) => void;
+
+export type AutoAccessorDecorator<
+  TContract,
+  TTarget,
+  K extends PublicMemberKey = PublicMemberKey,
+> = (
+  value: ClassAccessorDecoratorTarget<TContract, TTarget>,
+  context: ClassAccessorDecoratorContext<TContract, TTarget> & { name: K },
+) => void;
+
+export interface AccessorDecoratorFactory<TContract, TTarget, TMetadata> {
+  (...args: MetadataArgs<TMetadata>):
+    & GetterDecorator<any, TTarget>
+    & SetterDecorator<any, TTarget>
+    & AutoAccessorDecorator<any, TTarget>;
+
+  <K extends KeysOfType<TContract, TTarget>>(
+    ...args: DirectKeyedMetadataArgs<K, TMetadata>
+  ):
+    & GetterDecorator<TContract, TContract[K], K>
+    & SetterDecorator<TContract, TContract[K], K>
+    & AutoAccessorDecorator<TContract, TContract[K], K>;
+
+  on<K extends KeysOfType<TContract, TTarget>>(
+    ...args: KeyedMetadataArgs<K, TMetadata>
+  ):
+    & GetterDecorator<TContract, TContract[K], K>
+    & SetterDecorator<TContract, TContract[K], K>
+    & AutoAccessorDecorator<TContract, TContract[K], K>;
+}
+
+export type ScopedDecoratorBuilder<TSchema extends DecoratorSchema, TContract> = {
+  class<K extends StringKeyOf<TSchema['class']>>(
+    name: K,
+  ): StandardClassDecorator<TContract, MetadataOf<TSchema['class'][K]>>;
+
+  property<K extends StringKeyOf<TSchema['property']>>(
+    name: K,
+  ): PropertyDecoratorFactory<
+    TContract,
+    TargetOf<TSchema['property'][K]>,
+    MetadataOf<TSchema['property'][K]>
+  >;
+
+  method<K extends StringKeyOf<TSchema['method']>>(
+    name: K,
+  ): MethodDecoratorFactory<
+    TContract,
+    Extract<TargetOf<TSchema['method'][K]>, AnyFunction>,
+    MetadataOf<TSchema['method'][K]>
+  >;
+
+  accessor<K extends StringKeyOf<TSchema['accessor']>>(
+    name: K,
+  ): AccessorDecoratorFactory<
+    TContract,
+    TargetOf<TSchema['accessor'][K]>,
+    MetadataOf<TSchema['accessor'][K]>
+  >;
+};
+
+export interface DecoratorRegistry<TSchema extends DecoratorSchema> {
+  readonly namespace: string;
+  readonly allowPrivateMembers: boolean;
+
+  class<K extends StringKeyOf<TSchema['class']>>(
+    name: K,
+  ): UnscopedClassDecoratorFactory<MetadataOf<TSchema['class'][K]>>;
+
+  for<TContract>(): ScopedDecoratorBuilder<TSchema, TContract>;
+
+  read(target: Constructor | object, options?: RegistryReadOptions): RegistryMetadataSnapshot;
+}

package/src/decorators/validation/validatable.ts

@@ -0,0 +1,63 @@
+// import {createDecoratorRegistry} from "../factory";
+// export class ValidatableClass<T = any> {}
+//
+// type CrudDecorators = {
+//     class:{
+//         crud: {
+//             metadata: {
+//                 aiTool?: boolean,
+//                 listable?: boolean,
+//                 filters?: string[],
+//                 sorting?: string[],
+//             }
+//         }
+//     },
+//     property: {
+//         CrudID: {
+//             metadata: {
+//                 editable: false,
+//             },
+//             target: string
+//         },
+//         CrudProperty: {
+//             metadata: {
+//                 editable: boolean | "onCreate" | "onEdit",
+//                 source?: "body" | "param" | "query" | "header" // Defaults to body.
+//             },
+//             target: string | boolean | number | Date,
+//         },
+//     },
+//     method: {},
+//     accessor: {},
+// }
+// const registry = createDecoratorRegistry<CrudDecorators>({ namespace: 'crud-example' });
+// const ValidatableRegistry = registry.for<ValidatableClass>()
+// const CRUD = ValidatableRegistry.class('crud');
+// const CrudProperty = ValidatableRegistry.property('CrudProperty');
+// const CrudID =  ValidatableRegistry.property('CrudID');
+//
+//
+// @CRUD({
+//     aiTool: true,
+//     listable: true,
+//     filters: [],
+//     sorting: [],
+// })
+// export class CrudExample {
+//     @CrudID({
+//         editable: false
+//     })
+//     id!: string
+//
+//     @CrudProperty({
+//         editable: false
+//     })
+//     property!: string
+//
+//     @CrudProperty({
+//         editable: true,
+//     })
+//     other!: string
+// }
+//
+// const x = registry.read(CrudExample);

package/src/index.ts

@@ -0,0 +1,9 @@
+export const TestConstant = 1;
+export  class TestClass {
+    constructor() {
+    }
+}
+
+export function TestFunction(){
+
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "lib": ["ES2022", "DOM", "esnext.decorators"],
+    "rootDir": "./src",
+    "declaration": true,
+    "outDir": "./build",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": false,
+    "emitDecoratorMetadata": false,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.type-test.ts"]
+}

package/tsconfig.type-tests.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "src/type-tests/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"]
+}