@rockster/core 0.0.1

package/database/interfaces/column-def.d.ts

@@ -0,0 +1,26 @@
+import { ColumnOptions, ColumnType, PrimaryColumnOptions } from "typeorm";
+import { ColumnDefType, PrimaryStrategyType } from "./enum";
+import { PrimaryGeneratedColumnIdentityOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnIdentityOptions";
+import { PrimaryGeneratedColumnUUIDOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions";
+import { PrimaryGeneratedColumnNumericOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnNumericOptions";
+interface IBaseDef {
+    propertyKey: string;
+    designType: Function;
+}
+export interface IColumnDef extends IBaseDef {
+    defType: ColumnDefType.column;
+    type: ColumnType;
+    options?: ColumnOptions;
+}
+export interface IIdColumnDef extends IBaseDef {
+    defType: ColumnDefType.id;
+    type: ColumnType;
+    options?: PrimaryColumnOptions;
+}
+export interface IGeneratedIdColumnDef extends IBaseDef {
+    defType: ColumnDefType.generatedId;
+    strategy: PrimaryStrategyType;
+    options?: PrimaryGeneratedColumnIdentityOptions | PrimaryGeneratedColumnUUIDOptions | PrimaryGeneratedColumnNumericOptions;
+}
+export type ColumnDef = IColumnDef | IIdColumnDef | IGeneratedIdColumnDef;
+export {};

package/database/interfaces/column-def.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/connection.options.d.ts

@@ -0,0 +1,15 @@
+import { PostgresConnectionOptions } from "typeorm/driver/postgres/PostgresConnectionOptions";
+import { PostgresConnectionCredentialsOptions } from "typeorm/driver/postgres/PostgresConnectionCredentialsOptions";
+export interface IPostgresConnectionCredentialsOptions extends PostgresConnectionCredentialsOptions {
+}
+export interface IPostgresConnectionOptions extends Omit<PostgresConnectionOptions, 'type' | 'namingStrategy'> {
+    readonly replication?: {
+        readonly master: IPostgresConnectionCredentialsOptions;
+        readonly slaves: IPostgresConnectionCredentialsOptions[];
+    };
+    /**
+     * Use transaction or not. Default: true
+     */
+    transaction?: boolean;
+}
+export type ConnectionOptions = IPostgresConnectionOptions;

package/database/interfaces/connection.options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/direact-alias.d.ts

@@ -0,0 +1 @@
+export type DirectAlias = () => string;

package/database/interfaces/direact-alias.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/entity-object.d.ts

@@ -0,0 +1,15 @@
+import { IProtectedEntityOptions } from "..";
+import { ObjectType } from "../../common";
+import { IObject } from "../../core";
+import { IsAuthorizedHandle, Protector } from "./protector";
+export interface IEntityObject extends IObject {
+    type: ObjectType.entity;
+    alias: string;
+    tableName: string;
+    strict?: boolean;
+    idProperty: string;
+    protected?: IProtectedEntityOptions;
+    protector?: Protector;
+    isAuthorized?: IsAuthorizedHandle;
+    isProtect?: boolean;
+}

package/database/interfaces/entity-object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/entity-options.d.ts

@@ -0,0 +1,15 @@
+import { EntityOptions } from "typeorm";
+export interface IEntityOptions extends EntityOptions {
+    /**
+     * Override default alias
+     */
+    alias?: string;
+    /**
+     * Override default tableName
+     */
+    tableName?: string;
+    /**
+     * Reproduces the same behavior as a put method on the rest
+     */
+    strict?: boolean;
+}

package/database/interfaces/entity-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/entity-property.d.ts

@@ -0,0 +1,19 @@
+import { InverseAliasDef } from "./inverse-alias";
+import { GetTypeCallback, PropertyType } from "../../common";
+export interface IEntityProperty {
+    type: PropertyType.entity;
+    primitiveType: string;
+    columnType: string;
+    columnName: string;
+    getRelationType?: GetTypeCallback;
+    isIdProperty?: boolean;
+    isRelation?: boolean;
+    directAlias?: string;
+    inverseAlias?: InverseAliasDef;
+    isProtectContext?: boolean;
+    isProtectTarget?: boolean;
+    isProtectKey?: boolean;
+    strategy?: string;
+    isVirtual?: boolean;
+    getNewId?: () => string;
+}

package/database/interfaces/entity-property.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/enum/column-def-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum ColumnDefType {
+    column = "column",
+    id = "id",
+    generatedId = "generatedId"
+}

package/database/interfaces/enum/column-def-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnDefType = void 0;
+var ColumnDefType;
+(function (ColumnDefType) {
+    ColumnDefType["column"] = "column";
+    ColumnDefType["id"] = "id";
+    ColumnDefType["generatedId"] = "generatedId";
+})(ColumnDefType || (exports.ColumnDefType = ColumnDefType = {}));

package/database/interfaces/enum/index.d.ts

@@ -0,0 +1,5 @@
+export * from './column-def-type';
+export * from './order-by-direction';
+export * from './primary-strategy-type';
+export * from './relation-path-type';
+export * from './naming-strategy-type';

package/database/interfaces/enum/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./column-def-type"), exports);
+__exportStar(require("./order-by-direction"), exports);
+__exportStar(require("./primary-strategy-type"), exports);
+__exportStar(require("./relation-path-type"), exports);
+__exportStar(require("./naming-strategy-type"), exports);

package/database/interfaces/enum/naming-strategy-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum NamingStrategyType {
+    pascalCase = "pascalCase",
+    camelCase = "camelCase",
+    snakeCase = "snakeCase"
+}

package/database/interfaces/enum/naming-strategy-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamingStrategyType = void 0;
+var NamingStrategyType;
+(function (NamingStrategyType) {
+    NamingStrategyType["pascalCase"] = "pascalCase";
+    NamingStrategyType["camelCase"] = "camelCase";
+    NamingStrategyType["snakeCase"] = "snakeCase";
+})(NamingStrategyType || (exports.NamingStrategyType = NamingStrategyType = {}));

package/database/interfaces/enum/nano-id-alphabet-type.d.ts

@@ -0,0 +1,14 @@
+export declare enum NanoIdAlphabetType {
+    urlAlphabet = "urlAlphabet",
+    lowerCaseLettersAndDigits = "lowerCaseLettersAndDigits",
+    lowerCaseLetters = "lowerCaseLetters",
+    letters = "letters",
+    lettersAndDigits = "lettersAndDigits",
+    hexadecimalLowerCase = "hexadecimalLowerCase",
+    hexadecimalUppercase = "hexadecimalUppercase",
+    digits = "digits",
+    noLookAlikes = "noLookAlikes",
+    noLookAlikesSafe = "noLookAlikesSafe",
+    uppercaseLetters = "uppercaseLetters",
+    uppercaseLettersAndDigits = "uppercaseLettersAndDigits"
+}

package/database/interfaces/enum/nano-id-alphabet-type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NanoIdAlphabetType = void 0;
+var NanoIdAlphabetType;
+(function (NanoIdAlphabetType) {
+    NanoIdAlphabetType["urlAlphabet"] = "urlAlphabet";
+    NanoIdAlphabetType["lowerCaseLettersAndDigits"] = "lowerCaseLettersAndDigits";
+    NanoIdAlphabetType["lowerCaseLetters"] = "lowerCaseLetters";
+    NanoIdAlphabetType["letters"] = "letters";
+    NanoIdAlphabetType["lettersAndDigits"] = "lettersAndDigits";
+    NanoIdAlphabetType["hexadecimalLowerCase"] = "hexadecimalLowerCase";
+    NanoIdAlphabetType["hexadecimalUppercase"] = "hexadecimalUppercase";
+    NanoIdAlphabetType["digits"] = "digits";
+    NanoIdAlphabetType["noLookAlikes"] = "noLookAlikes";
+    NanoIdAlphabetType["noLookAlikesSafe"] = "noLookAlikesSafe";
+    NanoIdAlphabetType["uppercaseLetters"] = "uppercaseLetters";
+    NanoIdAlphabetType["uppercaseLettersAndDigits"] = "uppercaseLettersAndDigits";
+})(NanoIdAlphabetType || (exports.NanoIdAlphabetType = NanoIdAlphabetType = {}));

package/database/interfaces/enum/order-by-direction.d.ts

@@ -0,0 +1,4 @@
+export declare enum OrderByDirection {
+    asc = "asc",
+    desc = "desc"
+}

package/database/interfaces/enum/order-by-direction.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderByDirection = void 0;
+var OrderByDirection;
+(function (OrderByDirection) {
+    OrderByDirection["asc"] = "asc";
+    OrderByDirection["desc"] = "desc";
+})(OrderByDirection || (exports.OrderByDirection = OrderByDirection = {}));

package/database/interfaces/enum/primary-strategy-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum PrimaryStrategyType {
+    increment = "increment",
+    uuid = "uuid",
+    identity = "identity"
+}

package/database/interfaces/enum/primary-strategy-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryStrategyType = void 0;
+var PrimaryStrategyType;
+(function (PrimaryStrategyType) {
+    PrimaryStrategyType["increment"] = "increment";
+    PrimaryStrategyType["uuid"] = "uuid";
+    PrimaryStrategyType["identity"] = "identity";
+})(PrimaryStrategyType || (exports.PrimaryStrategyType = PrimaryStrategyType = {}));

package/database/interfaces/enum/relation-path-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum RelationPathType {
+    indirect = "indirect",
+    direct = "direct"
+}

package/database/interfaces/enum/relation-path-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationPathType = void 0;
+var RelationPathType;
+(function (RelationPathType) {
+    RelationPathType["indirect"] = "indirect";
+    RelationPathType["direct"] = "direct";
+})(RelationPathType || (exports.RelationPathType = RelationPathType = {}));

package/database/interfaces/execute-callback.d.ts

@@ -0,0 +1,3 @@
+export type ExecuteCallback = {
+    (): Promise<void>;
+};

package/database/interfaces/execute-callback.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/id-column-def.d.ts

@@ -0,0 +1,6 @@
+import { ColumnType, PrimaryColumnOptions } from "typeorm";
+export type IdColumnDef = {
+    propertyKey: string;
+    type: ColumnType;
+    options?: PrimaryColumnOptions;
+};

package/database/interfaces/id-column-def.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/index.d.ts

@@ -0,0 +1,17 @@
+export * from './enum';
+export * from './base-columns-name-override';
+export * from './column-def';
+export * from './connection.options';
+export * from './direact-alias';
+export * from './entity-object';
+export * from './entity-options';
+export * from './entity-property';
+export * from './execute-callback';
+export * from './id-column-def';
+export * from './inverse-alias';
+export * from './path';
+export * from './protector';
+export * from './relation-def';
+export * from './relation-path';
+export * from './relation.options';
+export * from './repository';

package/database/interfaces/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enum"), exports);
+__exportStar(require("./base-columns-name-override"), exports);
+__exportStar(require("./column-def"), exports);
+__exportStar(require("./connection.options"), exports);
+__exportStar(require("./direact-alias"), exports);
+__exportStar(require("./entity-object"), exports);
+__exportStar(require("./entity-options"), exports);
+__exportStar(require("./entity-property"), exports);
+__exportStar(require("./execute-callback"), exports);
+__exportStar(require("./id-column-def"), exports);
+__exportStar(require("./inverse-alias"), exports);
+__exportStar(require("./path"), exports);
+__exportStar(require("./protector"), exports);
+__exportStar(require("./relation-def"), exports);
+__exportStar(require("./relation-path"), exports);
+__exportStar(require("./relation.options"), exports);
+__exportStar(require("./repository"), exports);

package/database/interfaces/inverse-alias.d.ts

@@ -0,0 +1,5 @@
+export type InverseAliasDef = {
+    alias: string;
+    mapTo: string;
+};
+export type InverseAlias = () => InverseAliasDef;

package/database/interfaces/inverse-alias.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/nano-id-column-options.d.ts

@@ -0,0 +1,12 @@
+import { PrimaryGeneratedColumnUUIDOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions";
+import { NanoIdAlphabetType } from "./enum/nano-id-alphabet-type";
+export interface NanoIdColumnOpitons extends PrimaryGeneratedColumnUUIDOptions {
+    /**
+     * Default: NanoIdAlphabetType.lowerCaseLettersAndDigits
+     */
+    customAlphabet?: NanoIdAlphabetType;
+    /**
+     * Default: 12
+     */
+    size?: number;
+}

package/database/interfaces/nano-id-column-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/path.d.ts

@@ -0,0 +1,43 @@
+import { EntityManager } from "typeorm";
+import { GetTypeCallback } from "../../common";
+import { IQueryContent } from "../../query/interfaces/query";
+import { SelectQueryBuilder } from "../extensions/select-query-builder";
+export type GetConditionCallback<Entity> = {
+    (queryBuilder: SelectQueryBuilder<Entity>, queryContent: IQueryContent<Entity>, entityManager: EntityManager): string;
+};
+export type RootPath<Entity> = {
+    alias: string;
+    target: GetTypeCallback<Entity>;
+    paths?: Paths<Entity>;
+    secure?: boolean;
+    /**
+     * @deprecated Use context variable
+     */
+    contextData?: Object;
+    /**
+     * Used to enforce auxiliary parameters like context ids
+     */
+    context?: GetTypeCallback;
+};
+export type DirectPath<Entity> = {
+    type?: 'direct';
+    alias: string;
+    target: GetTypeCallback<Entity>;
+    paths?: Paths<Entity>;
+    linkProperty?: string;
+    secure?: boolean;
+    condition?: string | (GetConditionCallback<Entity>);
+};
+export type IndirectPath<Entity> = {
+    type?: 'indirect';
+    alias: string;
+    target: GetTypeCallback<Entity>;
+    paths?: Paths<Entity>;
+    linkProperty?: string;
+    secure?: boolean;
+    condition?: string | GetConditionCallback<Entity>;
+};
+export type Path<Entity> = DirectPath<Entity> | IndirectPath<Entity>;
+export type Paths<Entity> = {
+    [key in keyof Entity]?: Path<any>;
+};

package/database/interfaces/path.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/protector.d.ts

@@ -0,0 +1,51 @@
+import { Dictionary, Instantiable } from "@rockster/common";
+import { EntityManager, SelectQueryBuilder } from "typeorm";
+export type IsAuthorizedHandle = {
+    (args: {
+        userId: string;
+        keys: string[];
+        contextId?: string;
+        entityManager?: EntityManager;
+        context?: string;
+    }): Promise<void>;
+};
+export type GetUserPermissionsHandle = {
+    (args: {
+        userId: string;
+        targetUserId: string;
+        contextId: string;
+        entityManager?: EntityManager;
+        context: string;
+    }): Promise<string[]>;
+};
+export type SetUserPermissionsHandle = {
+    (args: {
+        userId: string;
+        targetUserId: string;
+        contextId: string;
+        entityManager?: EntityManager;
+        context: string;
+        accessKeys: string[];
+    }): Promise<void>;
+};
+export type Protector = {
+    target: Instantiable;
+    rootCondition?: (args: {
+        rootAlias: string;
+        queryBuilder: SelectQueryBuilder<any>;
+        userId: string;
+        contextParams: Dictionary<any>;
+    }) => SelectQueryBuilder<any>;
+    relationCondition?: (args: {
+        userId: string;
+        contextParams: Dictionary<any>;
+        alias: string;
+        rootPath: Instantiable;
+    }) => string;
+    canRemove?: (userId: string, entityId: string, entityManager?: EntityManager) => Promise<void>;
+    canModify?: <Entity>(userId: string, value: Entity, entityManager?: EntityManager) => Promise<void>;
+    canCreate?: <Entity>(userId: string, value: Entity, entityManager?: EntityManager) => Promise<void>;
+    isAuthorized?: IsAuthorizedHandle;
+    getUserPermissions?: GetUserPermissionsHandle;
+    setUserPermissions?: SetUserPermissionsHandle;
+};

package/database/interfaces/protector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/register-one-to-many-handle.d.ts

@@ -0,0 +1,3 @@
+export type RegisterOneToManyHandle = {
+    (): void;
+};

package/database/interfaces/register-one-to-many-handle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/register-one-to-many.d.ts

@@ -0,0 +1,6 @@
+import { GetTypeCallback } from "@rockster/common";
+import { RegisterOneToManyHandle } from "./register-one-to-many-handle";
+export type RegisterOneToMany = {
+    type: GetTypeCallback;
+    handle: RegisterOneToManyHandle;
+};

package/database/interfaces/register-one-to-many.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/relation-def.d.ts

@@ -0,0 +1,8 @@
+import { GetTypeCallback } from "../../common";
+import { RelationOptions } from "./relation.options";
+export type RelationDef = {
+    propertyKey: string;
+    type: GetTypeCallback;
+    options?: RelationOptions;
+    designType: Function;
+};

package/database/interfaces/relation-def.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/relation-path.d.ts

@@ -0,0 +1,10 @@
+import { ObjectNote, PropertyNote } from "@rockster/class-memory";
+import { RelationPathType } from "./enum";
+import { IEntityObject, IEntityProperty } from "..";
+export type RelationPath = {
+    type: RelationPathType;
+    parent?: RelationPath;
+    object: ObjectNote<IEntityObject>;
+    property: PropertyNote<IEntityProperty>;
+    recursive?: boolean;
+};

package/database/interfaces/relation-path.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/relation.options.d.ts

@@ -0,0 +1,9 @@
+import { RelationOptions as TypeOrmRelationOptions } from 'typeorm';
+import { DirectAlias } from './direact-alias';
+import { InverseAlias } from './inverse-alias';
+export type RelationOptions = {
+    directAlias?: DirectAlias;
+    inverseAlias?: InverseAlias;
+    referencedColumnName?: string;
+    name?: string;
+} & TypeOrmRelationOptions;

package/database/interfaces/relation.options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/interfaces/repository.d.ts

@@ -0,0 +1,8 @@
+import { EntityManager, Repository as TypeOrmRepository } from "typeorm";
+type AddEntityManagerToMethod<T extends (...args: any) => any> = (entityManager: EntityManager, ...args: Parameters<T>) => ReturnType<T>;
+export type Repository<T> = {
+    [P in keyof TypeOrmRepository<T> as TypeOrmRepository<T>[P] extends (...args: any) => any ? never : P]: TypeOrmRepository<T>[P];
+} & {
+    [P in keyof TypeOrmRepository<T> as TypeOrmRepository<T>[P] extends (...args: any) => any ? P : never]: TypeOrmRepository<T>[P] extends (...args: any) => any ? AddEntityManagerToMethod<TypeOrmRepository<T>[P]> : never;
+} & Partial<TypeOrmRepository<T>>;
+export {};

package/database/interfaces/repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/migrations/1737637321043-UUIDVarcharMigration.d.ts

@@ -0,0 +1,5 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+export declare class UUIDVarcharMigration1737637321043 implements MigrationInterface {
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}