@m5kdev/commons 0.1.0

package/dist/src/modules/recurrence/recurrence.schema.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRecurrenceRulesSchema = exports.deleteRecurrenceSchema = exports.updateRecurrenceSchema = exports.createRecurrenceSchema = exports.updateRecurrenceRulesSchema = exports.recurrenceRulesSchema = exports.recurrenceSchema = exports.recurrenceMetadataSchema = void 0;
+const zod_1 = require("zod");
+// Reusable schemas for JSON-by-* fields (number or number[])
+const numberOrNumberArraySchema = zod_1.z.union([zod_1.z.number(), zod_1.z.array(zod_1.z.number())]).nullish();
+exports.recurrenceMetadataSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullish();
+exports.recurrenceSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    userId: zod_1.z.string().nullish(),
+    organizationId: zod_1.z.string().nullish(),
+    teamId: zod_1.z.string().nullish(),
+    name: zod_1.z.string().nullish(),
+    kind: zod_1.z.string().nullish(),
+    enabled: zod_1.z.boolean(),
+    metadata: exports.recurrenceMetadataSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.recurrenceRulesSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    recurrenceId: zod_1.z.string().nullish(),
+    freq: zod_1.z.number(),
+    dtstart: zod_1.z.date().nullish(),
+    interval: zod_1.z.number(),
+    wkst: zod_1.z.number().nullish(),
+    count: zod_1.z.number().nullish(),
+    until: zod_1.z.date().nullish(),
+    tzid: zod_1.z.string().nullish(),
+    bysetpos: numberOrNumberArraySchema,
+    bymonth: numberOrNumberArraySchema,
+    bymonthday: numberOrNumberArraySchema,
+    byyearday: numberOrNumberArraySchema,
+    byweekno: numberOrNumberArraySchema,
+    byweekday: numberOrNumberArraySchema,
+    byhour: numberOrNumberArraySchema,
+    byminute: numberOrNumberArraySchema,
+    bysecond: numberOrNumberArraySchema,
+});
+exports.updateRecurrenceRulesSchema = exports.recurrenceRulesSchema.omit({
+    createdAt: true,
+    updatedAt: true,
+    recurrenceId: true,
+});
+exports.createRecurrenceSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    kind: zod_1.z.string(),
+    enabled: zod_1.z.boolean(),
+    metadata: exports.recurrenceMetadataSchema,
+    recurrenceRules: zod_1.z.array(exports.updateRecurrenceRulesSchema.omit({ id: true })),
+});
+exports.updateRecurrenceSchema = zod_1.z.object({
+    name: zod_1.z.string().optional(),
+    kind: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean().optional(),
+    metadata: exports.recurrenceMetadataSchema,
+});
+exports.deleteRecurrenceSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+});
+exports.deleteRecurrenceRulesSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+});

package/dist/src/modules/schemas/query.schema.d.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+export declare const filterSchema: z.ZodObject<{
+    columnId: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+    }>;
+    method: z.ZodEnum<{
+        contains: "contains";
+        equals: "equals";
+        starts_with: "starts_with";
+        ends_with: "ends_with";
+        greater_than: "greater_than";
+        less_than: "less_than";
+        on: "on";
+        between: "between";
+        before: "before";
+        after: "after";
+        oneOf: "oneOf";
+        intersect: "intersect";
+        isEmpty: "isEmpty";
+        isNotEmpty: "isNotEmpty";
+        is_null: "is_null";
+        is_not_null: "is_not_null";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+    valueTo: z.ZodOptional<z.ZodString>;
+    endColumnId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const filtersSchema: z.ZodArray<z.ZodObject<{
+    columnId: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+    }>;
+    method: z.ZodEnum<{
+        contains: "contains";
+        equals: "equals";
+        starts_with: "starts_with";
+        ends_with: "ends_with";
+        greater_than: "greater_than";
+        less_than: "less_than";
+        on: "on";
+        between: "between";
+        before: "before";
+        after: "after";
+        oneOf: "oneOf";
+        intersect: "intersect";
+        isEmpty: "isEmpty";
+        isNotEmpty: "isNotEmpty";
+        is_null: "is_null";
+        is_not_null: "is_not_null";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+    valueTo: z.ZodOptional<z.ZodString>;
+    endColumnId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const querySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        columnId: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            date: "date";
+            enum: "enum";
+        }>;
+        method: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+            greater_than: "greater_than";
+            less_than: "less_than";
+            on: "on";
+            between: "between";
+            before: "before";
+            after: "after";
+            oneOf: "oneOf";
+            intersect: "intersect";
+            isEmpty: "isEmpty";
+            isNotEmpty: "isNotEmpty";
+            is_null: "is_null";
+            is_not_null: "is_not_null";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+        valueTo: z.ZodOptional<z.ZodString>;
+        endColumnId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type QueryListOutput<T> = {
+    rows: T[];
+    total: number;
+};
+export type QueryInput = z.infer<typeof querySchema>;
+export type QueryFilter = z.infer<typeof filterSchema>;
+export type QueryFilters = z.infer<typeof filtersSchema>;
+//# sourceMappingURL=query.schema.d.ts.map

package/dist/src/modules/schemas/query.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.schema.d.ts","sourceRoot":"","sources":["../../../../src/modules/schemas/query.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBvB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAwB,CAAC;AAEnD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOtB,CAAC;AAEH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/src/modules/schemas/query.schema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.querySchema = exports.filtersSchema = exports.filterSchema = void 0;
+const zod_1 = require("zod");
+exports.filterSchema = zod_1.z.object({
+    columnId: zod_1.z.string(),
+    type: zod_1.z.enum(["string", "number", "date", "boolean", "enum"]),
+    method: zod_1.z.enum([
+        "contains",
+        "equals",
+        "starts_with",
+        "ends_with",
+        "greater_than",
+        "less_than",
+        "on",
+        "between",
+        "before",
+        "after",
+        "oneOf",
+        "intersect",
+        "isEmpty",
+        "isNotEmpty",
+        "is_null",
+        "is_not_null",
+    ]),
+    value: zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean(), zod_1.z.array(zod_1.z.string())]),
+    valueTo: zod_1.z.string().optional(),
+    endColumnId: zod_1.z.string().optional(),
+});
+exports.filtersSchema = zod_1.z.array(exports.filterSchema);
+exports.querySchema = zod_1.z.object({
+    // TODO: Remove default values
+    page: zod_1.z.number().optional(),
+    limit: zod_1.z.number().optional(),
+    sort: zod_1.z.string().optional(),
+    order: zod_1.z.enum(["asc", "desc"]).optional(),
+    filters: exports.filtersSchema.optional(),
+});

package/dist/src/modules/table/filter.types.d.ts

@@ -0,0 +1,13 @@
+import type { QueryFilter } from "../schemas/query.schema";
+export type ColumnDataType = NonNullable<QueryFilter["type"]>;
+export type ComponentForFilterMethod = "text" | "number" | "date" | "range" | "radio" | "select" | "multiSelect";
+export type FilterMethodName = "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "intersect" | "oneOf" | "isEmpty" | "isNotEmpty";
+export type FilterMethod = {
+    value: FilterMethodName;
+    label: string;
+    component?: ComponentForFilterMethod | null;
+};
+export type FilterMethods = {
+    [key in ColumnDataType]: FilterMethod[];
+};
+//# sourceMappingURL=filter.types.d.ts.map

package/dist/src/modules/table/filter.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.types.d.ts","sourceRoot":"","sources":["../../../../src/modules/table/filter.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AAE9D,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,QAAQ,GACR,MAAM,GACN,OAAO,GACP,OAAO,GACP,QAAQ,GACR,aAAa,CAAC;AAElB,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,QAAQ,GACR,aAAa,GACb,WAAW,GACX,cAAc,GACd,WAAW,GACX,IAAI,GACJ,SAAS,GACT,QAAQ,GACR,OAAO,GACP,WAAW,GACX,OAAO,GACP,SAAS,GACT,YAAY,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;KACzB,GAAG,IAAI,cAAc,GAAG,YAAY,EAAE;CACxC,CAAC"}

package/dist/src/modules/table/filter.types.js

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

package/dist/src/modules/tag/tag.schema.d.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+export declare const tagSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    teamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    userId: z.ZodString;
+    name: z.ZodString;
+    color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isEnabled: z.ZodBoolean;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assignableTo: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export declare const taggingSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    tagId: z.ZodString;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+}, z.core.$strip>;
+export declare const tagListInputSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        columnId: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            date: "date";
+            enum: "enum";
+        }>;
+        method: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+            greater_than: "greater_than";
+            less_than: "less_than";
+            on: "on";
+            between: "between";
+            before: "before";
+            after: "after";
+            oneOf: "oneOf";
+            intersect: "intersect";
+            isEmpty: "isEmpty";
+            isNotEmpty: "isNotEmpty";
+            is_null: "is_null";
+            is_not_null: "is_not_null";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+        valueTo: z.ZodOptional<z.ZodString>;
+        endColumnId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const tagListOutputSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        teamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        userId: z.ZodString;
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isEnabled: z.ZodBoolean;
+        parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assignableTo: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export declare const tagListSchema: z.ZodObject<{
+    assignableTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const tagCreateSchema: z.ZodObject<{
+    organizationId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    color: z.ZodString;
+    assignableTo: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    resourceType: z.ZodOptional<z.ZodString>;
+    resourceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const tagUpdateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const tagLinkSchema: z.ZodObject<{
+    tagId: z.ZodString;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+}, z.core.$strip>;
+export type TagSchema = z.infer<typeof tagSchema>;
+export type TaggingSchema = z.infer<typeof taggingSchema>;
+export type TagListSchema = z.infer<typeof tagListSchema>;
+export type TagCreateSchema = z.infer<typeof tagCreateSchema>;
+export type TagUpdateSchema = z.infer<typeof tagUpdateSchema>;
+export type TagLinkSchema = z.infer<typeof tagLinkSchema>;
+export type TagListOutputSchema = z.infer<typeof tagListOutputSchema>;
+export type TagListInputSchema = z.infer<typeof tagListInputSchema>;
+//# sourceMappingURL=tag.schema.d.ts.map

package/dist/src/modules/tag/tag.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.schema.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;iBAcpB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;iBAMxB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAc,CAAC;AAE9C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;iBAG9B,CAAC;AAEH,eAAO,MAAM,aAAa;;iBAExB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;iBAQ1B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/src/modules/tag/tag.schema.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagLinkSchema = exports.tagUpdateSchema = exports.tagCreateSchema = exports.tagListSchema = exports.tagListOutputSchema = exports.tagListInputSchema = exports.taggingSchema = exports.tagSchema = void 0;
+const zod_1 = require("zod");
+const query_schema_1 = require("../schemas/query.schema");
+exports.tagSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    organizationId: zod_1.z.string().nullish(),
+    teamId: zod_1.z.string().nullish(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date().nullish(),
+    deletedAt: zod_1.z.date().nullish(),
+    userId: zod_1.z.string(),
+    name: zod_1.z.string(),
+    color: zod_1.z.string().nullish(),
+    type: zod_1.z.string().nullish(),
+    isEnabled: zod_1.z.boolean(),
+    parentId: zod_1.z.string().nullish(),
+    assignableTo: zod_1.z.string().array().nullish().default([]),
+});
+exports.taggingSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    tagId: zod_1.z.string(),
+    resourceType: zod_1.z.string(),
+    resourceId: zod_1.z.string(),
+});
+exports.tagListInputSchema = query_schema_1.querySchema;
+exports.tagListOutputSchema = zod_1.z.object({
+    rows: zod_1.z.array(exports.tagSchema),
+    total: zod_1.z.number(),
+});
+exports.tagListSchema = zod_1.z.object({
+    assignableTo: zod_1.z.string().optional(),
+});
+exports.tagCreateSchema = zod_1.z.object({
+    organizationId: zod_1.z.string().optional(),
+    teamId: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+    color: zod_1.z.string(),
+    assignableTo: zod_1.z.string().array().optional().default([]),
+    resourceType: zod_1.z.string().optional(),
+    resourceId: zod_1.z.string().optional(),
+});
+exports.tagUpdateSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    color: zod_1.z.string().optional(),
+});
+exports.tagLinkSchema = zod_1.z.object({
+    tagId: zod_1.z.string(),
+    resourceType: zod_1.z.string(),
+    resourceId: zod_1.z.string(),
+});

package/dist/src/modules/workflow/workflow.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const WORFLOW_STATUSES: readonly ["queued", "running", "completed", "failed"];
+export type WorkflowStatus = (typeof WORFLOW_STATUSES)[number];
+//# sourceMappingURL=workflow.constants.d.ts.map

package/dist/src/modules/workflow/workflow.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.constants.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,uDAAwD,CAAC;AACtF,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/src/modules/workflow/workflow.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORFLOW_STATUSES = void 0;
+exports.WORFLOW_STATUSES = ["queued", "running", "completed", "failed"];

package/dist/src/modules/workflow/workflow.schema.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const workflowSelectSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodNullable<z.ZodString>;
+    jobId: z.ZodString;
+    jobName: z.ZodString;
+    queueName: z.ZodString;
+    tags: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    retries: z.ZodNumber;
+    finishedAt: z.ZodNullable<z.ZodDate>;
+    processedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const workflowReadInputSchema: z.ZodObject<{
+    jobId: z.ZodString;
+}, z.core.$strip>;
+export declare const workflowListInputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>>>;
+    jobName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const workflowTriggerOutputSchema: z.ZodObject<{
+    jobId: z.ZodString;
+}, z.core.$strip>;
+export declare const workflowTriggerManyOutputSchema: z.ZodObject<{
+    jobIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const workflowReadOutputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodNullable<z.ZodString>;
+    jobId: z.ZodString;
+    jobName: z.ZodString;
+    queueName: z.ZodString;
+    tags: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    retries: z.ZodNumber;
+    finishedAt: z.ZodNullable<z.ZodDate>;
+    processedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const workflowListOutputSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodNullable<z.ZodString>;
+    jobId: z.ZodString;
+    jobName: z.ZodString;
+    queueName: z.ZodString;
+    tags: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    retries: z.ZodNumber;
+    finishedAt: z.ZodNullable<z.ZodDate>;
+    processedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>>;
+export type WorkflowSelectSchema = z.infer<typeof workflowSelectSchema>;
+export type WorkflowReadInputSchema = z.infer<typeof workflowReadInputSchema>;
+export type WorkflowListInputSchema = z.infer<typeof workflowListInputSchema>;
+export type WorkflowReadOutputSchema = z.infer<typeof workflowReadOutputSchema>;
+export type WorkflowListOutputSchema = z.infer<typeof workflowListOutputSchema>;
+export type WorkflowTriggerOutputSchema = z.infer<typeof workflowTriggerOutputSchema>;
+export type WorkflowTriggerManyOutputSchema = z.infer<typeof workflowTriggerManyOutputSchema>;
+//# sourceMappingURL=workflow.schema.d.ts.map

package/dist/src/modules/workflow/workflow.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.schema.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;iBAE1C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAAuB,CAAC;AAC7D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;kBAA+B,CAAC;AAErE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAChF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAChF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AACtF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/src/modules/workflow/workflow.schema.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowListOutputSchema = exports.workflowReadOutputSchema = exports.workflowTriggerManyOutputSchema = exports.workflowTriggerOutputSchema = exports.workflowListInputSchema = exports.workflowReadInputSchema = exports.workflowSelectSchema = void 0;
+const zod_1 = require("zod");
+const workflow_constants_1 = require("./workflow.constants");
+exports.workflowSelectSchema = zod_1.z.object({
+    id: zod_1.z.uuid(),
+    userId: zod_1.z.string().nullable(),
+    jobId: zod_1.z.string(),
+    jobName: zod_1.z.string(),
+    queueName: zod_1.z.string(),
+    tags: zod_1.z.array(zod_1.z.string()).nullable(),
+    input: zod_1.z.unknown(),
+    output: zod_1.z.unknown(),
+    status: zod_1.z.enum(workflow_constants_1.WORFLOW_STATUSES),
+    error: zod_1.z.string().nullable(),
+    retries: zod_1.z.number(),
+    finishedAt: zod_1.z.date().nullable(),
+    processedAt: zod_1.z.date().nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.workflowReadInputSchema = zod_1.z.object({
+    jobId: zod_1.z.string(),
+});
+exports.workflowListInputSchema = zod_1.z.object({
+    status: zod_1.z.enum(workflow_constants_1.WORFLOW_STATUSES).array().optional(),
+    jobName: zod_1.z.string().optional(),
+});
+exports.workflowTriggerOutputSchema = zod_1.z.object({
+    jobId: zod_1.z.string(),
+});
+exports.workflowTriggerManyOutputSchema = zod_1.z.object({
+    jobIds: zod_1.z.array(zod_1.z.string()),
+});
+exports.workflowReadOutputSchema = exports.workflowSelectSchema;
+exports.workflowListOutputSchema = exports.workflowSelectSchema.array();

package/dist/src/utils/json.d.ts

@@ -0,0 +1,3 @@
+export declare function safeParseJson<T>(json: string, fallback: T): T;
+export declare function safeParseJson<T>(json: string): T | undefined;
+//# sourceMappingURL=json.d.ts.map

package/dist/src/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/utils/json.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;AAC/D,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC"}

package/dist/src/utils/json.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeParseJson = safeParseJson;
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/src/utils/timezones.d.ts

@@ -0,0 +1,15 @@
+export type Timezone = {
+    name: string;
+    alternativeName: string;
+    group: string[];
+    continentCode: string;
+    continentName: string;
+    countryName: string;
+    countryCode: string;
+    mainCities: string[];
+    rawOffsetInMinutes: number;
+    abbreviation: string;
+    rawFormat: string;
+};
+export declare const timezones: Timezone[];
+//# sourceMappingURL=timezones.d.ts.map

package/dist/src/utils/timezones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timezones.d.ts","sourceRoot":"","sources":["../../../src/utils/timezones.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,QAAQ,EA6wI/B,CAAC"}