lucy-cli 2.0.0-beta.8 → 2.0.0-beta.9

package/files/templates/velo[D]/files/typescript/public/models/collections/subscriptions.model.ts

@@ -0,0 +1,80 @@
+import { satisfies } from 'effect/Function';
+import { Schema } from 'effect/index';
+
+export const futuresSchema = Schema.Literal('create_event', 'create_organization');
+export const planSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	order: Schema.Number,
+	features: Schema.Array(futuresSchema),
+	limits: Schema.Struct({
+		organizations: Schema.Number,
+		events: Schema.Number,
+	}),
+});
+
+export const availablePlans = satisfies<typeof planSchema.Type[]>()([
+	{
+		id: '00000000-0000-0000-0000-000000000000',
+		name: 'free',
+		order: 0,
+		features: [ 'create_event', 'create_organization' ],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+	{
+		id: '26b02e36-6d07-41d8-ae49-8241756b4270',
+		name: '1 Jahr kostenlos',
+		order: 1,
+		features: ['create_event', 'create_organization'],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+	{
+		id: 'a86edd6d-8d7e-468d-b763-838674cff834',
+		name: 'Einsteiger',
+		order: 2,
+		features: ['create_event', 'create_organization'],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+	{
+		id: '9c6b158e-2689-45c0-95a3-8c0e596a69ce',
+		name: 'Hobby',
+		order: 3,
+		features: [],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+	{
+		id: 'c7de837b-7463-4508-a89c-d7deec3fc9fd',
+		name: 'Teilzeit',
+		order: 4,
+		features: ['create_event', 'create_organization'],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+	{
+		id: 'c1e48401-1126-4834-be26-6fd5df9d5ffe',
+		name: 'Vollzeit',
+		order: 5,
+		features: ['create_event', 'create_organization'],
+		limits: {
+			organizations: 2,
+			events: 1
+		},
+	},
+] as const);
+export const subscriptionsSchema = Schema.Literal(...availablePlans.map(plan => plan.id));
+
+

package/files/templates/velo[D]/files/typescript/public/models/collections/tag.model.ts

@@ -0,0 +1,15 @@
+import { Schema } from 'effect/index';
+import { wixItemBaseSchema } from 'public/lib/models/wix/common/collection.model';
+
+export const tagBaseSchema = Schema.Struct({
+	name: Schema.String,
+	description: Schema.String,
+	image: Schema.String,
+});
+
+export const tagSchema = Schema.Struct({
+	...wixItemBaseSchema.fields,
+	...tagBaseSchema.fields,
+});
+
+export const tagsSchema = Schema.Array(tagSchema);

package/files/templates/velo[D]/files/typescript/public/models/collections/translations.model.ts

@@ -0,0 +1,16 @@
+import { Schema } from 'effect/index';
+import { wixItemBaseSchema } from 'public/lib/models/wix/common/collection.model';
+
+export const translationBaseSchema = Schema.Struct({
+	key: Schema.String,
+	language: Schema.String,
+	text: Schema.optional(Schema.String),
+	rich_text: Schema.optional(Schema.String),
+	rich_content: Schema.optional(Schema.String),
+});
+
+export const translationSchema = Schema.Struct({
+	...wixItemBaseSchema.fields,
+	...translationBaseSchema.fields,
+});
+export const translationsSchema = Schema.Array(translationSchema);

package/files/templates/velo[D]/files/typescript/public/models/modules/authz.model.ts

@@ -0,0 +1,31 @@
+import { Schema } from 'effect/index';
+import { jwtBaseSchema } from 'public/lib/models/dto/jwt.mode';
+
+import { Roles } from '../../config';
+import { availablePlans, planSchema } from '../collections/subscriptions.model';
+
+export const subscriptionSchema = Schema.Union(planSchema);
+export type Subscription = typeof subscriptionSchema.Type;
+export const organizationDetails = Schema.Struct({
+	organizationId: Schema.String,
+	organizationSlug: Schema.optional(Schema.String),
+	organizationSubscriptionId: Schema.Literal(...availablePlans.map(plan => plan.id)),
+	roles: Schema.mutable(Schema.Array(Schema.Enums(Roles))),
+});
+
+export const rolesByOrgCollectionSchema = Schema.Struct({
+	user: Schema.Struct({
+		id: Schema.String,
+		subscription: Schema.NullOr(subscriptionSchema),
+	}),
+	organizations: Schema.Array(organizationDetails),
+	isSuperAdmin: Schema.Boolean,
+});
+export type AuthzData = typeof rolesByOrgCollectionSchema.Type;
+
+export const jwtSchema = Schema.Struct({
+	...jwtBaseSchema.fields,
+	...rolesByOrgCollectionSchema.fields,
+});
+
+//Schema.optional(Schema.Union(...availablePlans.map(plan => Schema.Literal(typeof plan))))

package/files/templates/velo[D]/files/typescript/public/models/modules/organization.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'effect/index';
+import { createResponseDTOSchema } from 'public/lib/dto/response.dto';
+import { createRequestDTOSchema } from 'public/lib/dto/shared/request.dto';
+import { ResponseDTO } from 'public/lib/models/dto/response.model';
+import { multireferenceSchema } from 'public/lib/models/wix/common/common.model';
+import { organizationSchema } from 'public/models/collections/organization.model';
+
+import { stageSchema } from '../collections/stage.model';
+import { tagSchema } from '../collections/tag.model';
+
+export const organizationFullSchema = Schema.Struct({
+	...organizationSchema.fields,
+	tags: multireferenceSchema(tagSchema),
+	stage: stageSchema, // Assuming stage is a string, adjust if it's different 
+});
+
+// export type GetOrganizationDTO = ResponseDTO<typeof organizationFullSchema.Type | undefined>;
+// export const getOrganizationDTOSchema = createResponseDTOSchema(organizationFullSchema);
+// export type GetSingleOrganizationDTO = ResponseDTO<typeof organizationFullSchema.Type>;
+// export const requestOrganizationDTOSchema = createRequestDTOSchema(Schema.String);

package/files/templates/velo[D]/files/typescript/public/models/splitwise.model.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+
+export const userSchema = Schema.Struct({
+	label: Schema.String,
+	value: Schema.String,
+});
+
+export const userListSchema = Schema.mutable(Schema.Array(userSchema));
+
+export const responseSchema = Schema.Struct({
+	status: Schema.String,
+	message: Schema.String,
+});
+
+
+export type UserList = typeof userListSchema.Type;
+
+export type Response = typeof responseSchema.Type;

package/files/templates/velo[D]/files/typescript/public/models/store/local.model.ts

@@ -0,0 +1,10 @@
+import { tablesBaseSchema, valuesBaseSchema } from 'public/lib/models/store/local';
+
+export const tablesSchema = {
+	// pets: { species: { type: 'string' }, age: { type: 'number' }, puppie: { type: 'boolean' } },
+	...tablesBaseSchema,
+} as const;
+
+export const valuesSchema = {
+	...valuesBaseSchema,
+} as const;

package/files/templates/velo[D]/files/typescript/public/models/store/memory.model.ts

@@ -0,0 +1,10 @@
+import { tablesBaseSchema, valuesBaseSchema } from 'public/lib/models/store/memory';
+
+export const tablesSchema = {
+	// pets: { species: { type: 'string' } },
+	...tablesBaseSchema,
+} as const;
+
+export const valuesSchema = {
+	...valuesBaseSchema,
+} as const;

package/files/templates/velo[D]/files/typescript/public/models/store/session.model.ts

@@ -0,0 +1,10 @@
+import { tablesBaseSchema, valuesBaseSchema } from 'public/lib/models/store/session';
+
+export const tablesSchema = {
+	...tablesBaseSchema,
+} as const;
+
+export const valuesSchema = {
+	...valuesBaseSchema,
+} as const;
+

package/files/templates/velo[D]/files/typescript/public/models/wix/ecom/payment.ts

@@ -0,0 +1,236 @@
+import { z } from 'zod';
+
+const addressSchema = z.object({
+    addressLine1: z.string().optional(),
+    addressLine2: z.string().optional(),
+    city: z.string().optional(),
+    country: z.string().optional(),
+    postalCode: z.string().optional(),
+    streetAddress: z.object({
+        name: z.string().optional(),
+        number: z.string().optional(),
+    }).optional(),
+    subdivision: z.string().optional(),
+});
+
+const fullAddressContactDetailsSchema = z.object({
+    company: z.string().optional(),
+    firstName: z.string().optional(),
+    lastName: z.string().optional(),
+    phone: z.string().optional(),
+    vatId: z.object({
+        _id: z.string().optional(),
+        type: z.enum(['CNPJ', 'CPF', 'UNSPECIFIED']).optional(),
+    }).optional(),
+});
+
+const itemTaxFullDetailsSchema = z.object({
+    taxRate: z.string().optional(),
+    taxableAmount: z.object({
+    amount: z.string(),
+    }).optional(),
+    totalTax: z.object({
+        amount: z.string(),
+    }).optional(),
+});
+
+const priceSchema = z.object({
+    amount: z.string(),
+    formattedAmount: z.string().optional(),
+});
+
+const lineItemSchema = z.object({
+    productName: z.object({
+        original: z.string(),
+        translated: z.string().optional(),
+    }),
+    catalogReference: z.object({
+        catalogItemId: z.string(),
+        appId: z.string(),
+        options: z.object({
+            options: z.record(z.unknown()),
+            variantId: z.string().optional(),
+        }).optional(),
+    }),
+    quantity: z.number(),
+    totalDiscount: priceSchema.optional(),
+    descriptionLines: z.array(z.string()).optional(),
+    image: z.string().optional(),
+    physicalProperties: z.object({
+        sku: z.string(),
+        shippable: z.boolean(),
+    }).optional(),
+    itemType: z.object({
+        preset: z.string(),
+    }).optional(),
+    price: priceSchema,
+    priceBeforeDiscounts: priceSchema.optional(),
+    totalPriceBeforeTax: priceSchema.optional(),
+    totalPriceAfterTax: priceSchema.optional(),
+    paymentOption: z.string().optional(),
+    taxDetails: itemTaxFullDetailsSchema.optional(),
+    taxInfo: z.object({
+        taxAmount: priceSchema.optional(),
+        taxableAmount: priceSchema.optional(),
+        taxRate: z.string(),
+        taxIncludedInPrice: z.boolean().optional(),
+        taxBreakdown: z.array(z.unknown()).optional(),
+    }).optional(),
+    digitalFile: z.object({
+        fileId: z.string(),
+        expirationDate: z.union([z.string(), z.date()]), // Accepts either a string or a date
+    }).optional(),
+    locations: z.array(z.unknown()).optional(),
+    lineItemPrice: priceSchema.optional(),
+    customLineItem: z.boolean().optional(),
+    rootCatalogItemId: z.string().optional(),
+    taxableAddress: z.object({
+        addressType: z.string(),
+    }).optional(),
+    _id: z.string(),
+});
+
+const appliedDiscountSchema = z.object({
+    _id: z.string(),
+    discountType: z.enum(['GLOBAL', 'SHIPPING', 'SPECIFIC_ITEMS']),
+    lineItemIds: z.array(z.string()).optional(),
+    coupon: z.object({
+        _id: z.string().optional(),
+        amount: priceSchema.optional(),
+        code: z.string().optional(),
+        name: z.string().optional(),
+    }).optional(),
+    discountRule: z.object({
+        _id: z.string().optional(),
+        amount: priceSchema.optional(),
+        name: z.object({
+            original: z.string(),
+            translated: z.string(),
+        }),
+    }).optional(),
+    merchantDiscount: z.object({
+        amount: priceSchema,
+        description: z.string().optional(),
+        discountReason: z.enum(['EXCHANGED_ITEMS', 'UNSPECIFIED']).optional(),
+    }).optional(),
+});
+
+const additionalFeeSchema = z.object({
+    _id: z.string(),
+    code: z.string(),
+    lineItemIds: z.array(z.string()).optional(),
+    name: z.string(),
+    price: priceSchema,
+    priceAfterTax: priceSchema.optional(),
+    priceBeforeTax: priceSchema.optional(),
+    providerAppId: z.string().optional(),
+    taxDetails: itemTaxFullDetailsSchema.optional(),
+});
+
+const eventMetadataSchema = z.object({
+    id: z.string(),
+    entityId: z.string(),
+    eventTime: z.string(),
+    triggeredByAnonymizeRequest: z.boolean().optional(),
+});
+
+const orderSchema = z.object({
+    number: z.string(),
+    lineItems: z.array(lineItemSchema),
+    buyerInfo: z.object({
+        contactId: z.string(),
+        email: z.string(),
+        memberId: z.string().optional(),
+        visitorId: z.string().optional(),
+        buyerLanguage: z.string().optional(), // Made optional to avoid the error
+        buyerNote: z.string().optional(),
+    }),
+    paymentStatus: z.enum(['FULLY_REFUNDED', 'NOT_PAID', 'PAID', 'PARTIALLY_PAID', 'PARTIALLY_REFUNDED', 'PENDING', 'UNSPECIFIED']),
+    fulfillmentStatus: z.string().optional(),
+    currency: z.string(),
+    taxIncludedInPrices: z.boolean(),
+    siteLanguage: z.string().optional(),
+    priceSummary: z.object({
+        subtotal: priceSchema,
+        shipping: priceSchema.optional(),
+        tax: priceSchema.optional(),
+        discount: priceSchema.optional(),
+        totalPrice: priceSchema,
+        total: priceSchema,
+        totalWithGiftCard: priceSchema.optional(),
+        totalWithoutGiftCard: priceSchema.optional(),
+        totalAdditionalFees: priceSchema.optional(),
+    }),
+    billingInfo: z.object({
+        address: addressSchema.optional(),
+        contactDetails: fullAddressContactDetailsSchema,
+    }).optional(),
+    status: z.enum(['APPROVED', 'CANCELED', 'INITIALIZED']),
+    archived: z.boolean(),
+    taxSummary: z.object({
+        totalTax: priceSchema.optional(),
+        manualTaxRate: z.string().optional(),
+    }).optional(),
+    taxInfo: z.object({
+        totalTax: priceSchema.optional(),
+        taxBreakdown: z.array(z.unknown()).optional(),
+        manualTaxRate: z.string().optional(),
+    }).optional(),
+    appliedDiscounts: z.array(appliedDiscountSchema).optional(),
+    activities: z.array(
+        z.object({
+            type: z.string(),
+            _id: z.string(),
+            _createdDate: z.union([z.string(), z.date()]), // Accepts either a string or a date
+        })
+    ),
+    attributionSource: z.enum(['FACEBOOK_ADS', 'UNSPECIFIED']).optional(),
+    createdBy: z.record(z.unknown()).optional(),
+    channelInfo: z.object({
+        type: z.enum([
+            'AMAZON', 'BACKOFFICE_MERCHANT', 'CLASS_PASS', 'EBAY', 'ETSY',
+            'FACEBOOK', 'FAIRE_COM', 'GLOBAL_E', 'OTHER_PLATFORM', 'POS',
+            'TIKTOK', 'UNSPECIFIED', 'WEB', 'WISH', 'WIX_APP_STORE', 'WIX_INVOICES'
+        ]),
+    }).optional(),
+    seenByAHuman: z.boolean().optional(),
+    checkoutId: z.string().optional(),
+    customFields: z.array(z.unknown()).optional(),
+    cartId: z.string().optional(),
+    isInternalOrderCreate: z.boolean().optional(),
+    payNow: z.object({
+        subtotal: priceSchema,
+        shipping: priceSchema.optional(),
+        tax: priceSchema.optional(),
+        discount: priceSchema.optional(),
+        totalPrice: priceSchema,
+        total: priceSchema,
+        totalWithGiftCard: priceSchema.optional(),
+        totalWithoutGiftCard: priceSchema.optional(),
+        totalAdditionalFees: priceSchema.optional(),
+    }).optional(),
+    balanceSummary: z.object({
+        balance: priceSchema,
+        paid: priceSchema,
+        refunded: priceSchema.optional(),
+        authorized: priceSchema.optional(),
+        pendingRefund: priceSchema.optional(),
+    }).optional(),
+    additionalFees: z.array(additionalFeeSchema).optional(),
+    purchaseFlowId: z.string().optional(),
+    recipientInfo: z.object({
+        address: addressSchema.optional(), // Made optional to avoid the error
+        contactDetails: fullAddressContactDetailsSchema,
+    }).optional(),
+});
+
+export const orderPaymentStatusUpdatedSchema = z.object({
+    metadata: eventMetadataSchema,
+    data: z.object({
+        order: orderSchema,
+        previousPaymentStatus: z.enum(['FULLY_REFUNDED', 'NOT_PAID', 'PAID', 'PARTIALLY_PAID', 'PARTIALLY_REFUNDED', 'PENDING', 'UNSPECIFIED']).optional(),
+    }),
+});
+
+export type OrderPaymentStatusUpdated = z.infer<typeof orderPaymentStatusUpdatedSchema>;
+export type OrderSchema = z.infer<typeof orderSchema>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "lucy-cli",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0-beta.9",
   "description": "Lucy Framework for WIX Studio Editor",
   "main": ".dist/index.js",
   "repository": {

package/src/helpers.ts

@@ -89,13 +89,5 @@ export function cleanupWatchers() {
 
     logger.info(`Cleaning watchers for directory: ${cwd}`);
     const result = spawnSync(command, { shell: true, encoding: 'utf-8' });
-
-    // if (result.stderr) {
-    //     logger.error(`spawnSync error: ${result.stderr}`);
-    //     return;
-    // }
-    // if (!result.stdout.trim()) {
-    //     logger.info(`No watchers found to clean up.`);
-    //     return;
-    // }
+    return result;
 }

package/src/index.ts

@@ -20,8 +20,9 @@ export function setNeedsCleanup(value: boolean) {
 process.on('exit', (code) => {
     if(!needsCleanup) return;
     if(exitReason === 'none') {
-	    killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	    killAllProcesses('@wix/cli/bin/wix.cjs');
         killAllProcesses('wix:dev');   
+        killAllProcesses('wix dev');   
         cleanupWatchers();
     }
 
@@ -34,6 +35,7 @@ process.on('SIGINT', () => {
 	logger.info(`🐕 Received Ctrl+C (SIGINT), cleaning up...`);
 	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
 	killAllProcesses('wix:dev');  
+    killAllProcesses('wix dev');  
     cleanupWatchers();
     process.exit(); // Exit explicitly after handling
 });
@@ -44,6 +46,7 @@ process.on('SIGTERM', () => {
 	logger.info(`🛑 Received termination signal (SIGTERM), cleaning up...`);
 	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
 	killAllProcesses('wix:dev');  
+    killAllProcesses('wix dev');  
     cleanupWatchers();
     process.exit(); // Exit explicitly after handling
 });

package/src/init/index.ts

@@ -14,7 +14,9 @@ import { init_submodules } from "./gitModules.js";
 import { init_tauri } from "./tauri.js";
 import { pkgManagers } from "../schemas/lucy.js";
 
-
+//TODO: Get Templates from Reposytory
+//TODO: Update Local tsconfig for libs
+//TODO: Fix PNPM in VELO
 export const init = Effect.gen(function* (_) {
     const config = yield* Config;
     if(config.config.action.initType === undefined) {

package/src/tasks/Gulpfile.ts

@@ -55,7 +55,7 @@ export const task_runGulp = Effect.gen(function* (_) {
 	logger.action(`Running task: ${task}`);
 
 	gulp.task('check-ts', gulp.parallel( 
-		checkTs(taskOptions),
+		checkTs(taskOptions, false),
 	));
 
 	gulp.task('scss', gulp.parallel( 

package/src/tasks/gulp/checks.ts

@@ -52,7 +52,7 @@ import { TaskType } from '../../schemas/types.js';
  * @param {string} filePath File path
  * @param {string} pattern Pattern to match
  */
-function extractMatchFromFile(filePath: string, pattern: string) {
+async function extractMatchFromFile(filePath: string, pattern: string) {
 	return new Promise((resolve, reject) => {
 		fs.readFile(filePath, 'utf8', (err, data) => {
 			if (err){
@@ -77,29 +77,30 @@ function extractMatchFromFile(filePath: string, pattern: string) {
 async function readFilesInFolder(folderPath: string, pattern: string | null, globPattern: string,) {
 	const files = await glob.glob(path.join(folderPath, globPattern));
 	const filenameList: Object[] = [];
-	function traverseFiles(index: number) {
+	async function traverseFiles(index: number) {
 		if (index === files.length){
 			return;
 		}
 		const file = files[index];
 		if(pattern){
 			if(!file) return
-			extractMatchFromFile(file, pattern)
-				.then((capturedGroup) => {
-					if (capturedGroup){
-						filenameList.push(capturedGroup);
-					}
-					traverseFiles(index + 1);
-				})
-				.catch(() => { throw new Error(`Error reading file: ${file}`); });
+			try {
+				const capturedGroup = await extractMatchFromFile(file, pattern);
+				if (capturedGroup){
+					filenameList.push(capturedGroup);
+				}
+			} catch (error) {
+				throw new Error(`Error reading file: ${file}`);
+			}
 		}
 		if(!pattern){
 			if(!file) return
 			filenameList.push(path.basename(file));
-			traverseFiles(index + 1);
 		}
+		await traverseFiles(index + 1);
+
 	}
-	traverseFiles(0);
+	await traverseFiles(0);
 	
 	return filenameList;
 }
@@ -107,7 +108,7 @@ export async function checkPages(fail: boolean, force: boolean) {
 	logger.action('Checking pages...');
 	return new Promise<void>(async (resolve, reject) => {
 		try {
-			const sourcePages = await readFilesInFolder('./.wix/types/', '\\/pages\\/(?<page>.*\\.ts)', '**/*.json',) as string[];
+			const sourcePages = await readFilesInFolder('./.wix/types/', '\\/pages\\/(?<page>.*\\.ts)', '*/*.json',) as string[];
 			const tsPages = await readFilesInFolder('./typescript/pages', null, '**/*.ts',) as string[];
 
 			const sourcePagesSet = new Set(sourcePages);
@@ -187,7 +188,7 @@ export function checkTs(options: TaskOptions, watching: boolean = false): TaskTy
     const task = (done: gulp.TaskFunctionCallback) => {
 		let hasError = false;
 		const stream = gulp
-			.src([`${folder}/**/*.ts`, `!${folder}/types/**/*.ts`])
+			.src([`${folder}/**/*.{ts,tsx}`, `!${folder}/types/**/*.ts`])
 			.pipe(tsProject(customReporter))
 			.on("error", (error) => {
 				hasError = true;

package/src/tasks/gulp/watchers.ts

@@ -35,7 +35,7 @@ export function watchAll(options: TaskOptions): TaskType {
             '*/public/**/*.tsx',
             '!src/**/*',
         ], gulp.parallel(
-            checkTs(options),
+            checkTs(options, true),
             buildPublic(options),
         ));
     }
@@ -43,7 +43,7 @@ export function watchAll(options: TaskOptions): TaskType {
     function watchPages() {
         return 	gulp.watch(['typescript/pages/**/*.ts', '!src/**/*',], 
         gulp.parallel(
-            checkTs(options),
+            checkTs(options, true),
             buildPages(options),
             )
         );
@@ -68,7 +68,7 @@ export function watchAll(options: TaskOptions): TaskType {
             '!src/**/*',
         ], gulp.parallel(
             previewTemplates(options),
-            checkTs(options),
+            checkTs(options, true),
             )
         );
     }