@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.20

package/src/dtos/change-mpin.dto.ts

@@ -0,0 +1,18 @@
+import { IsNotEmpty, IsString, MaxLength } from 'class-validator';
+
+export class ChangeMpinDto {
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(128)
+    credentialRef: string;
+
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(32)
+    currentMpin: string;
+
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(32)
+    newMpin: string;
+}

package/src/dtos/create-field-metadata.dto.ts

@@ -1,5 +1,6 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { Transform, Type } from 'class-transformer';
+import { MEDIA_CATEGORIES, MediaCategory } from '../constants/media-file-types';
 
 import {
   IsArray,
@@ -155,13 +156,7 @@ export enum DecryptWhenType {
   afterTransit = 'after-transit',
 }
 
-export enum MediaType {
-  image = 'image',
-  audio = 'audio',
-  video = 'video',
-  // document = 'document',
-  file = 'file',
-}
+export type MediaType = MediaCategory;
 
 export enum RelationType {
   manyToOne = 'many-to-one',
@@ -308,7 +303,7 @@ export class CreateFieldMetadataDto {
   private: boolean;
 
   @ApiProperty({ description: 'Allowed media types for the field. Only for type=mediaSingle,mediaMultiple', })
-  @IsEnum(MediaType, { each: true })
+  @IsIn([...MEDIA_CATEGORIES], { each: true })
   @IsOptional()
   mediaTypes: MediaType[];
 
@@ -464,4 +459,4 @@ export class CreateFieldMetadataDto {
   @ApiProperty({ description: 'Is Primary Key Field', })
   @IsBoolean()
   isPrimaryKey?: boolean;
-}
+}

package/src/dtos/create-model-sequence.dto.ts

@@ -35,7 +35,7 @@ export class CreateModelSequenceDto {
     @IsOptional()
     @IsInt()
     @ApiProperty()
-    currentValue: number;
+    currentValue?: number;
     @IsOptional()
     @IsString()
     @ApiProperty()

package/src/dtos/mpin-login.dto.ts

@@ -0,0 +1,24 @@
+import { IsNotEmpty, IsString, MaxLength } from 'class-validator';
+
+/**
+ * Deliberately carries no identifier - no mobile, email or username.
+ *
+ * `credentialRef` is a server-issued 256-bit handle that already points at a
+ * single credential row, and therefore at a single user. That is what removes
+ * the user-enumeration surface a public login route would otherwise have: an
+ * attacker cannot probe "does this phone number have MPIN?" because there is
+ * nowhere to put a phone number.
+ */
+export class MpinLoginDto {
+    // Bounded so a pathological payload never reaches the regex test or the
+    // hash comparison. The handle is always 64 hex characters.
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(128)
+    credentialRef: string;
+
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(32)
+    mpin: string;
+}

package/src/dtos/setup-mpin.dto.ts

@@ -0,0 +1,51 @@
+import { IsNotEmpty, IsOptional, IsString, IsUUID, Matches, MaxLength } from 'class-validator';
+
+export class SetupMpinDto {
+    /**
+     * Stable identifier for the physical device, generated once by the client.
+     * Validated as a UUID before it ever reaches a cache key or a bucket name,
+     * so it cannot smuggle delimiters into the keyspace.
+     */
+    @IsUUID()
+    deviceId: string;
+
+    /**
+     * A string, not a number, even though it looks like digits.
+     *
+     * A numeric MPIN cannot carry a leading zero: JSON forbids leading zeros in
+     * number literals, so a client serialising `012345` numerically emits
+     * `12345` and the server stores a five-digit MPIN the user never chose -
+     * which still satisfies the default `^\d{4,6}$` and so raises no error.
+     * `mpinRegex` is also tenant-configurable and may permit non-digits.
+     *
+     * Note this cannot be enforced here: the global ValidationPipe runs with
+     * `enableImplicitConversion`, so a numeric payload is coerced to a string
+     * before @IsString() sees it. Clients must send a quoted JSON string; that
+     * requirement is documented in the mobile integration guide.
+     *
+     * Length and shape are checked server-side against `mpinRegex`, since that
+     * setting is the single authority. This only bounds the input.
+     */
+    @IsNotEmpty()
+    @IsString()
+    @MaxLength(32)
+    mpin: string;
+
+    /**
+     * Rendered in a device-management list, so it is bounded here rather than
+     * trusting every consuming UI to escape it.
+     */
+    @IsOptional()
+    @IsString()
+    @MaxLength(64)
+    @Matches(/^[\w\s.'()-]*$/, {
+        message: 'deviceName may contain only letters, numbers, spaces and . \' ( ) - _',
+    })
+    deviceName?: string;
+
+    @IsOptional()
+    @IsString()
+    @MaxLength(32)
+    @Matches(/^[\w.-]*$/, { message: 'platform may contain only letters, numbers and . - _' })
+    platform?: string;
+}

package/src/entities/common.entity.ts

@@ -25,6 +25,30 @@ export abstract class CommonEntity {
     @Column({ name: 'published_at', default: null, nullable: true, transformer: LocalDateTimeTransformer })
     publishedAt: Date;
 
+    // Optional (not just nullable) because legacy tables (see LegacyCommonEntityWithExistingId)
+    // don't carry these versioning columns at all. CRUDService<T extends CommonEntity> is
+    // otherwise used for both plain and legacy entities, so these must stay structurally
+    // satisfiable by a type that never declares them.
+    @Expose()
+    @Column({ name: 'is_published', default: false })
+    @Index()
+    isPublished?: boolean;
+
+    @Expose()
+    @Column({ name: 'is_latest', default: true })
+    @Index()
+    isLatest?: boolean;
+
+    @Expose()
+    @Column({ type: "int", name: 'initial_entity_version_id', default: null, nullable: true })
+    @Index()
+    initialEntityVersionId?: number;
+
+    @Expose()
+    @Column({ name: 'published_tracker', default: "na" })
+    @Index()
+    publishedTracker?: string;
+
     @Expose()
     @Column({ type: "varchar", name: 'locale_name', default: null })
     localeName: string;

package/src/entities/dashboard-user-layout.entity.ts

@@ -6,12 +6,12 @@ import { ModuleMetadata } from 'src/entities/module-metadata.entity'
 @Entity('ss_dashboard_user_layout')
 export class DashboardUserLayout extends CommonEntity {
     @Index()
-    @ManyToOne(() => User, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => User, { nullable: false })
     @JoinColumn()
     user: User;
 
     @Index()
-    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn()
     module: ModuleMetadata;
 

package/src/entities/saved-filters.entity.ts

@@ -18,17 +18,17 @@ export class SavedFilters extends CommonEntity {
     isPrivate: boolean = false;
 
     @Index()
-    @ManyToOne(() => User, { onDelete: "CASCADE", nullable: true })
+    @ManyToOne(() => User, { nullable: true })
     @JoinColumn()
     user: User;
 
     @Index()
-    @ManyToOne(() => ModelMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModelMetadata, { nullable: false })
     @JoinColumn()
     model: ModelMetadata;
 
     @Index()
-    @ManyToOne(() => ViewMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ViewMetadata, { nullable: false })
     @JoinColumn()
     view: ViewMetadata;
 

package/src/entities/user-device-credential.entity.ts

@@ -0,0 +1,130 @@
+import { Exclude, Expose } from "class-transformer";
+import { CommonEntity } from "src/entities/common.entity";
+import { Column, Entity, Index, ManyToOne } from "typeorm";
+import { User } from "./user.entity";
+
+/**
+ * A per-device MPIN credential.
+ *
+ * Login presents `credentialRef` (a server-issued opaque handle) plus the MPIN.
+ * The handle - not a mobile number or email - is what identifies the account,
+ * which is why the login route needs no identifier and offers no user
+ * enumeration surface.
+ */
+@Entity("ss_user_device_credential")
+// Non-unique: one physical device may legitimately hold credentials for
+// several accounts, and each account setup mints its own row.
+@Index(["user", "deviceId"])
+@Exclude()
+export class UserDeviceCredential extends CommonEntity {
+
+    // SHA-256 of the opaque handle, and the login lookup key. Never exposed:
+    // the raw handle is returned to the client once at setup and never stored.
+    // SHA-256 rather than bcrypt because the handle is 256 bits of randomness -
+    // there is nothing to brute-force, so a slow hash would only add latency.
+    // Same treatment as UserApiKey.hashedKey.
+    @Index({ unique: true })
+    @Column()
+    hashedCredentialRef: string;
+
+    // bcrypt hash of the MPIN, via HashingService. Never exposed - same
+    // treatment as User.password. Slow hashing is warranted here: a 4-6 digit
+    // secret is exactly the low-entropy case bcrypt exists for.
+    @Column()
+    hashedMpin: string;
+
+    // Mirrors User.passwordScheme / passwordSchemeVersion so
+    // HashingService.needsRehash can upgrade the hash on a successful login.
+    @Column()
+    mpinScheme: string;
+
+    /**
+     * The hashing *policy* version this row was hashed under - not a version of
+     * MPIN itself. It comes from `HashingService.currentVersion()`, which
+     * `BcryptService` currently returns as **2**, so freshly created rows read
+     * 2, exactly as `ss_user.password_scheme_version` does.
+     *
+     * It matters because `BcryptService.normalize` applies the configured
+     * pepper only when `version >= 2`. Storing the version per row means an
+     * older hash still verifies after the policy changes: `compare()` uses the
+     * version the row was written with, and `needsRehash()` upgrades it on the
+     * next successful login.
+     *
+     * The `default: 1` is inherited from the `User` precedent and is never
+     * reached, since every write path sets this explicitly. Note it would be
+     * *wrong* if it ever were: a row hashed at 2 but recorded as 1 would be
+     * compared without the pepper and could never authenticate.
+     */
+    @Column({ default: 1 })
+    mpinSchemeVersion: number;
+
+    // Client-supplied, stable for the physical device. Used for grouping and
+    // the device-management UI only - never a lookup key. Deliberately NOT
+    // unique: several accounts on one device share a deviceId.
+    @Expose()
+    @Column()
+    deviceId: string;
+
+    /**
+     * Human-readable natural key - `<username>-<deviceId>` - unique per row.
+     *
+     * Neither column alone can serve as the model's user key: `deviceId` is
+     * shared by every account on a device, and `deviceName` is nullable.
+     * Combining them is unique in both directions - one user across many
+     * devices, and many users on one device.
+     *
+     * Populated by MpinService rather than declared as a `computed` field in
+     * the metadata manifest. Computed fields are evaluated by
+     * ComputedFieldCrudManager on the generic CRUD path (`crud.service.ts`),
+     * which this service bypasses by writing through the repository directly,
+     * so a computed declaration would silently leave this null. It is also
+     * beyond ConcatComputedFieldProvider, which resolves `dto[field]` flatly
+     * within one model and cannot reach `username` across the user relation.
+     */
+    @Expose()
+    @Index({ unique: true })
+    @Column()
+    credentialKey: string;
+
+    @Expose()
+    @Column({ nullable: true })
+    deviceName: string;
+
+    @Expose()
+    @Column({ nullable: true })
+    platform: string;
+
+    // Revocation is a soft-delete: the row survives so that a correct MPIN can
+    // be answered with "this device was removed" rather than a baffling
+    // "incorrect MPIN". Only active rows count towards mpinMaxDevicesPerUser.
+    @Expose()
+    @Column({ default: true })
+    isActive: boolean;
+
+    // Cumulative, and reset only on a successful login - never when a lockout
+    // expires. That is what makes the second threshold detectable without a
+    // separate lockout counter.
+    @Expose()
+    @Column({ default: 0 })
+    failedAttempts: number;
+
+    @Expose()
+    @Column({ nullable: true })
+    lockedUntil: Date;
+
+    @Expose()
+    @Column({ nullable: true })
+    lastUsedAt: Date;
+
+    // Deliberately no inverse property on User. Nothing needs
+    // `user.deviceCredentials`, and leaving the most widely referenced entity
+    // in the system untouched keeps this feature purely additive.
+    //
+    // `nullable: false` because TypeORM makes relations nullable by default,
+    // which would let a credential exist with no owner. Such a row could never
+    // authenticate - loginWithMpin rejects it - so it would simply be dead
+    // data, but the database should refuse it outright. This also keeps the
+    // column honest against the metadata manifest, which declares it required.
+    @ManyToOne(() => User, { nullable: false })
+    user: User;
+}

package/src/entities/user.entity.ts

@@ -5,6 +5,23 @@ import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
 import { UserApiKey } from 'src/entities/user-api-key.entity'
 import { Exclude, Expose } from "class-transformer";
 
+/**
+ * Serialization is locked down twice over, and both halves are load-bearing:
+ *
+ * - The class-level `@Exclude()` below makes User itself an allowlist: only `@Expose()`d
+ *   properties are serialized.
+ * - Every other property additionally carries its own `@Exclude()`. That looks redundant
+ *   here, and for `User` it is - but class-transformer resolves the *class-level* strategy
+ *   with a direct lookup on the exact constructor (MetadataStorage.getStrategy), so a
+ *   subclass inherits nothing and falls back to `exposeAll`. Since this entity is a
+ *   `@TableInheritance` root that consuming projects extend (see
+ *   IExtensionUserCreationProvider), an extension user that forgets its own `@Exclude()`
+ *   would otherwise serialize the password hash and every OAuth/verification token.
+ *   Property-level metadata *is* walked up the prototype chain, so the per-property
+ *   decorators are what actually protect subclasses.
+ *
+ * Keep both. Adding a new column? Give it `@Expose()` or `@Exclude()` - never neither.
+ */
 @Entity("ss_user")
 @TableInheritance({ column: { type: "varchar", name: "type", default: "User" } })
 @Exclude()
@@ -30,7 +47,7 @@ export class User extends CommonEntity {
     mobile: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     password: string;
 
     @Column({ nullable: true, default: true })
@@ -38,67 +55,67 @@ export class User extends CommonEntity {
     forcePasswordChange: boolean = true;
 
     @Column({ type: "varchar", default: "local" })
-    // don't send to client
+    @Exclude()
     lastLoginProvider: string = "local";
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client (test)
+    @Exclude()
     accessCode: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     googleAccessToken: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     googleId: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     googleProfilePicture: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     facebookId: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     facebookAccessToken: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     facebookProfilePicture: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     appleId: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     appleAccessToken: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftId: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftAccessToken: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftProfilePicture: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftActiveDirectoryId: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftActiveDirectoryAccessToken: string;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     microsoftActiveDirectoryProfilePicture: string;
 
     @Index()
@@ -107,63 +124,63 @@ export class User extends CommonEntity {
     active: boolean = true;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     forgotPasswordConfirmedAt: Date;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     verificationTokenOnForgotPassword: string;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     verificationTokenOnForgotPasswordExpiresAt: Date;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerifiedOnRegistrationAt: Date;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerificationTokenOnRegistration: string;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerificationTokenOnRegistrationExpiresAt: Date;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerifiedOnRegistrationAt: Date;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerificationTokenOnRegistration: string;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerificationTokenOnRegistrationExpiresAt: Date;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerifiedOnLoginAt: Date;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerificationTokenOnLogin: string;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     emailVerificationTokenOnLoginExpiresAt: Date;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerifiedOnLoginAt: Date;
 
     @Column({ type: "varchar", nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerificationTokenOnLogin: string;
 
     @Column({ nullable: true })
-    // don't send to client
+    @Exclude()
     mobileVerificationTokenOnLoginExpiresAt: Date;
 
     @Column({ type: "varchar", nullable: true })
@@ -176,18 +193,18 @@ export class User extends CommonEntity {
     roles: RoleMetadata[];
 
     @OneToMany(() => UserViewMetadata, userViewMetadata => userViewMetadata.user, { cascade: true })
-    // don't send to client
+    @Exclude()
     userViewMetadata: UserViewMetadata[];
 
-    // dont send to client
+    @Exclude()
     @Column({ type: "varchar", default: "bcrypt" })
     passwordScheme: string;
 
-    // dont send to client
+    @Exclude()
     @Column({ type: "int", default: 1 })
     passwordSchemeVersion: number;
 
-    // dont send to client
+    @Exclude()
     @Column({ nullable: true })
     rehashedAt: Date;
 

package/src/entities/view-metadata.entity.ts

@@ -19,11 +19,11 @@ export class ViewMetadata extends CommonEntity {
     @Column({ name: "type", type: "varchar" })
     type: string;
 
-    //TODO: To make this truly cross db compatible, we should avoid setting a db type
+    // TODO: To make this truly cross db compatible, we should avoid setting a db type  
     @Column({ name: "context", type: "text" })
     context: any = "{}";
 
-    //TODO: To make this truly cross db compatible, we should avoid setting a db type
+    // TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "layout", type: "text" })
     layout: any;
 

package/src/entities/workflow-execution-artifact.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { WorkflowExecution } from './workflow-execution.entity';
 import { WorkflowStepExecution } from './workflow-step-execution.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity('ss_workflow_execution_artifact')
 export class WorkflowExecutionArtifact extends CommonEntity {
@@ -10,12 +11,12 @@ export class WorkflowExecutionArtifact extends CommonEntity {
     artifactKey: string;
 
     @Index()
-    @ManyToOne(() => WorkflowExecution, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => WorkflowExecution, { nullable: false })
     @JoinColumn()
     workflowExecution: WorkflowExecution;
 
     @Index()
-    @ManyToOne(() => WorkflowStepExecution, { onDelete: "CASCADE", nullable: true })
+    @ManyToOne(() => WorkflowStepExecution, { nullable: true })
     @JoinColumn()
     workflowStepExecution: WorkflowStepExecution;
 
@@ -61,7 +62,7 @@ export class WorkflowExecutionArtifact extends CommonEntity {
     checksum: string;
 
     @Index()
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true, ...getColumnType('datetime') })
     producedAt: Date;
 
     @Column({ type: "simple-json", nullable: true })

package/src/entities/workflow-execution-log.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { WorkflowExecution } from './workflow-execution.entity';
 import { WorkflowStepExecution } from './workflow-step-execution.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity('ss_workflow_execution_log')
 export class WorkflowExecutionLog extends CommonEntity {
@@ -10,12 +11,12 @@ export class WorkflowExecutionLog extends CommonEntity {
     logKey: string;
 
     @Index()
-    @ManyToOne(() => WorkflowExecution, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => WorkflowExecution, { nullable: false })
     @JoinColumn()
     workflowExecution: WorkflowExecution;
 
     @Index()
-    @ManyToOne(() => WorkflowStepExecution, { onDelete: "CASCADE", nullable: true })
+    @ManyToOne(() => WorkflowStepExecution, { nullable: true })
     @JoinColumn()
     workflowStepExecution: WorkflowStepExecution;
 
@@ -47,7 +48,7 @@ export class WorkflowExecutionLog extends CommonEntity {
     sequenceNumber: number;
 
     @Index()
-    @Column({ type: "timestamp" })
+    @Column({ ...getColumnType('datetime') })
     occurredAt: Date;
 
     @Column({ type: "simple-json", nullable: true })

package/src/entities/workflow-execution.entity.ts

@@ -4,6 +4,7 @@ import { WorkflowDefinition } from './workflow-definition.entity'
 import { WorkflowStepExecution } from './workflow-step-execution.entity';
 import { WorkflowExecutionLog } from './workflow-execution-log.entity';
 import { WorkflowExecutionArtifact } from './workflow-execution-artifact.entity';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity('ss_workflow_execution')
 export class WorkflowExecution extends CommonEntity {
@@ -32,11 +33,11 @@ export class WorkflowExecution extends CommonEntity {
     triggerType: string = "manual";
 
     @Index()
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true, ...getColumnType('datetime') })
     startedAt: Date;
 
     @Index()
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true, ...getColumnType('datetime') })
     finishedAt: Date;
 
     @Column({ type: "bigint", nullable: true })